|
1501
|
1 // Copyright 2015-2025 The Khronos Group Inc.
|
|
|
2 //
|
|
|
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
4 //
|
|
|
5
|
|
|
6 // This header is generated from the Khronos Vulkan XML API Registry.
|
|
|
7
|
|
|
8 #ifndef VULKAN_HANDLES_HPP
|
|
|
9 #define VULKAN_HANDLES_HPP
|
|
|
10
|
|
|
11 // include-what-you-use: make sure, vulkan.hpp is used by code-completers
|
|
|
12 // IWYU pragma: private, include "vulkan/vulkan.hpp"
|
|
|
13
|
|
|
14 namespace VULKAN_HPP_NAMESPACE
|
|
|
15 {
|
|
|
16
|
|
|
17 //===================================
|
|
|
18 //=== STRUCT forward declarations ===
|
|
|
19 //===================================
|
|
|
20
|
|
|
21 //=== VK_VERSION_1_0 ===
|
|
|
22 struct Extent2D;
|
|
|
23 struct Extent3D;
|
|
|
24 struct Offset2D;
|
|
|
25 struct Offset3D;
|
|
|
26 struct Rect2D;
|
|
|
27 struct BaseInStructure;
|
|
|
28 struct BaseOutStructure;
|
|
|
29 struct BufferMemoryBarrier;
|
|
|
30 struct ImageMemoryBarrier;
|
|
|
31 struct MemoryBarrier;
|
|
|
32 struct AllocationCallbacks;
|
|
|
33 struct ApplicationInfo;
|
|
|
34 struct FormatProperties;
|
|
|
35 struct ImageFormatProperties;
|
|
|
36 struct InstanceCreateInfo;
|
|
|
37 struct MemoryHeap;
|
|
|
38 struct MemoryType;
|
|
|
39 struct PhysicalDeviceFeatures;
|
|
|
40 struct PhysicalDeviceLimits;
|
|
|
41 struct PhysicalDeviceMemoryProperties;
|
|
|
42 struct PhysicalDeviceProperties;
|
|
|
43 struct PhysicalDeviceSparseProperties;
|
|
|
44 struct QueueFamilyProperties;
|
|
|
45 struct DeviceCreateInfo;
|
|
|
46 struct DeviceQueueCreateInfo;
|
|
|
47 struct ExtensionProperties;
|
|
|
48 struct LayerProperties;
|
|
|
49 struct SubmitInfo;
|
|
|
50 struct MappedMemoryRange;
|
|
|
51 struct MemoryAllocateInfo;
|
|
|
52 struct MemoryRequirements;
|
|
|
53 struct BindSparseInfo;
|
|
|
54 struct ImageSubresource;
|
|
|
55 struct SparseBufferMemoryBindInfo;
|
|
|
56 struct SparseImageFormatProperties;
|
|
|
57 struct SparseImageMemoryBind;
|
|
|
58 struct SparseImageMemoryBindInfo;
|
|
|
59 struct SparseImageMemoryRequirements;
|
|
|
60 struct SparseImageOpaqueMemoryBindInfo;
|
|
|
61 struct SparseMemoryBind;
|
|
|
62 struct FenceCreateInfo;
|
|
|
63 struct SemaphoreCreateInfo;
|
|
|
64 struct QueryPoolCreateInfo;
|
|
|
65 struct BufferCreateInfo;
|
|
|
66 struct ImageCreateInfo;
|
|
|
67 struct SubresourceLayout;
|
|
|
68 struct ComponentMapping;
|
|
|
69 struct ImageSubresourceRange;
|
|
|
70 struct ImageViewCreateInfo;
|
|
|
71 struct CommandPoolCreateInfo;
|
|
|
72 struct CommandBufferAllocateInfo;
|
|
|
73 struct CommandBufferBeginInfo;
|
|
|
74 struct CommandBufferInheritanceInfo;
|
|
|
75 struct BufferCopy;
|
|
|
76 struct BufferImageCopy;
|
|
|
77 struct ImageCopy;
|
|
|
78 struct ImageSubresourceLayers;
|
|
|
79 struct DispatchIndirectCommand;
|
|
|
80 struct PipelineCacheHeaderVersionOne;
|
|
|
81 struct EventCreateInfo;
|
|
|
82 struct BufferViewCreateInfo;
|
|
|
83 struct ShaderModuleCreateInfo;
|
|
|
84 struct PipelineCacheCreateInfo;
|
|
|
85 struct ComputePipelineCreateInfo;
|
|
|
86 struct PipelineShaderStageCreateInfo;
|
|
|
87 struct SpecializationInfo;
|
|
|
88 struct SpecializationMapEntry;
|
|
|
89 struct PipelineLayoutCreateInfo;
|
|
|
90 struct PushConstantRange;
|
|
|
91 struct SamplerCreateInfo;
|
|
|
92 struct CopyDescriptorSet;
|
|
|
93 struct DescriptorBufferInfo;
|
|
|
94 struct DescriptorImageInfo;
|
|
|
95 struct DescriptorPoolCreateInfo;
|
|
|
96 struct DescriptorPoolSize;
|
|
|
97 struct DescriptorSetAllocateInfo;
|
|
|
98 struct DescriptorSetLayoutBinding;
|
|
|
99 struct DescriptorSetLayoutCreateInfo;
|
|
|
100 struct WriteDescriptorSet;
|
|
|
101 union ClearColorValue;
|
|
|
102 struct DrawIndexedIndirectCommand;
|
|
|
103 struct DrawIndirectCommand;
|
|
|
104 struct GraphicsPipelineCreateInfo;
|
|
|
105 struct PipelineColorBlendAttachmentState;
|
|
|
106 struct PipelineColorBlendStateCreateInfo;
|
|
|
107 struct PipelineDepthStencilStateCreateInfo;
|
|
|
108 struct PipelineDynamicStateCreateInfo;
|
|
|
109 struct PipelineInputAssemblyStateCreateInfo;
|
|
|
110 struct PipelineMultisampleStateCreateInfo;
|
|
|
111 struct PipelineRasterizationStateCreateInfo;
|
|
|
112 struct PipelineTessellationStateCreateInfo;
|
|
|
113 struct PipelineVertexInputStateCreateInfo;
|
|
|
114 struct PipelineViewportStateCreateInfo;
|
|
|
115 struct StencilOpState;
|
|
|
116 struct VertexInputAttributeDescription;
|
|
|
117 struct VertexInputBindingDescription;
|
|
|
118 struct Viewport;
|
|
|
119 struct AttachmentDescription;
|
|
|
120 struct AttachmentReference;
|
|
|
121 struct FramebufferCreateInfo;
|
|
|
122 struct RenderPassCreateInfo;
|
|
|
123 struct SubpassDependency;
|
|
|
124 struct SubpassDescription;
|
|
|
125 struct ClearAttachment;
|
|
|
126 struct ClearDepthStencilValue;
|
|
|
127 struct ClearRect;
|
|
|
128 union ClearValue;
|
|
|
129 struct ImageBlit;
|
|
|
130 struct ImageResolve;
|
|
|
131 struct RenderPassBeginInfo;
|
|
|
132
|
|
|
133 //=== VK_VERSION_1_1 ===
|
|
|
134 struct BindBufferMemoryInfo;
|
|
|
135 using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
|
|
|
136 struct BindImageMemoryInfo;
|
|
|
137 using BindImageMemoryInfoKHR = BindImageMemoryInfo;
|
|
|
138 struct MemoryDedicatedRequirements;
|
|
|
139 using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
|
|
|
140 struct MemoryDedicatedAllocateInfo;
|
|
|
141 using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
|
|
|
142 struct MemoryAllocateFlagsInfo;
|
|
|
143 using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
|
|
|
144 struct DeviceGroupCommandBufferBeginInfo;
|
|
|
145 using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
|
|
|
146 struct DeviceGroupSubmitInfo;
|
|
|
147 using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
|
|
|
148 struct DeviceGroupBindSparseInfo;
|
|
|
149 using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
|
|
|
150 struct BindBufferMemoryDeviceGroupInfo;
|
|
|
151 using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
|
|
|
152 struct BindImageMemoryDeviceGroupInfo;
|
|
|
153 using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
|
|
|
154 struct PhysicalDeviceGroupProperties;
|
|
|
155 using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
|
|
|
156 struct DeviceGroupDeviceCreateInfo;
|
|
|
157 using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
|
|
|
158 struct BufferMemoryRequirementsInfo2;
|
|
|
159 using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
|
|
|
160 struct ImageMemoryRequirementsInfo2;
|
|
|
161 using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
|
|
|
162 struct ImageSparseMemoryRequirementsInfo2;
|
|
|
163 using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
|
|
|
164 struct MemoryRequirements2;
|
|
|
165 using MemoryRequirements2KHR = MemoryRequirements2;
|
|
|
166 struct SparseImageMemoryRequirements2;
|
|
|
167 using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
|
|
|
168 struct PhysicalDeviceFeatures2;
|
|
|
169 using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
|
|
|
170 struct PhysicalDeviceProperties2;
|
|
|
171 using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
|
|
|
172 struct FormatProperties2;
|
|
|
173 using FormatProperties2KHR = FormatProperties2;
|
|
|
174 struct ImageFormatProperties2;
|
|
|
175 using ImageFormatProperties2KHR = ImageFormatProperties2;
|
|
|
176 struct PhysicalDeviceImageFormatInfo2;
|
|
|
177 using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
|
|
|
178 struct QueueFamilyProperties2;
|
|
|
179 using QueueFamilyProperties2KHR = QueueFamilyProperties2;
|
|
|
180 struct PhysicalDeviceMemoryProperties2;
|
|
|
181 using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
|
|
|
182 struct SparseImageFormatProperties2;
|
|
|
183 using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
|
|
|
184 struct PhysicalDeviceSparseImageFormatInfo2;
|
|
|
185 using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
|
|
|
186 struct ImageViewUsageCreateInfo;
|
|
|
187 using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
|
|
|
188 struct PhysicalDeviceProtectedMemoryFeatures;
|
|
|
189 struct PhysicalDeviceProtectedMemoryProperties;
|
|
|
190 struct DeviceQueueInfo2;
|
|
|
191 struct ProtectedSubmitInfo;
|
|
|
192 struct BindImagePlaneMemoryInfo;
|
|
|
193 using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
|
|
|
194 struct ImagePlaneMemoryRequirementsInfo;
|
|
|
195 using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
|
|
|
196 struct ExternalMemoryProperties;
|
|
|
197 using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
|
|
|
198 struct PhysicalDeviceExternalImageFormatInfo;
|
|
|
199 using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
|
|
|
200 struct ExternalImageFormatProperties;
|
|
|
201 using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
|
|
|
202 struct PhysicalDeviceExternalBufferInfo;
|
|
|
203 using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
|
|
|
204 struct ExternalBufferProperties;
|
|
|
205 using ExternalBufferPropertiesKHR = ExternalBufferProperties;
|
|
|
206 struct PhysicalDeviceIDProperties;
|
|
|
207 using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
|
|
|
208 struct ExternalMemoryImageCreateInfo;
|
|
|
209 using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
|
|
|
210 struct ExternalMemoryBufferCreateInfo;
|
|
|
211 using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
|
|
|
212 struct ExportMemoryAllocateInfo;
|
|
|
213 using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
|
|
|
214 struct PhysicalDeviceExternalFenceInfo;
|
|
|
215 using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
|
|
|
216 struct ExternalFenceProperties;
|
|
|
217 using ExternalFencePropertiesKHR = ExternalFenceProperties;
|
|
|
218 struct ExportFenceCreateInfo;
|
|
|
219 using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
|
|
|
220 struct ExportSemaphoreCreateInfo;
|
|
|
221 using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
|
|
|
222 struct PhysicalDeviceExternalSemaphoreInfo;
|
|
|
223 using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
|
|
|
224 struct ExternalSemaphoreProperties;
|
|
|
225 using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
|
|
|
226 struct PhysicalDeviceSubgroupProperties;
|
|
|
227 struct PhysicalDevice16BitStorageFeatures;
|
|
|
228 using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
|
|
|
229 struct PhysicalDeviceVariablePointersFeatures;
|
|
|
230 using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
|
|
|
231 using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
|
|
|
232 using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
|
|
|
233 struct DescriptorUpdateTemplateEntry;
|
|
|
234 using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
|
|
|
235 struct DescriptorUpdateTemplateCreateInfo;
|
|
|
236 using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
|
|
|
237 struct PhysicalDeviceMaintenance3Properties;
|
|
|
238 using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
|
|
|
239 struct DescriptorSetLayoutSupport;
|
|
|
240 using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
|
|
|
241 struct SamplerYcbcrConversionCreateInfo;
|
|
|
242 using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
|
|
|
243 struct SamplerYcbcrConversionInfo;
|
|
|
244 using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
|
|
|
245 struct PhysicalDeviceSamplerYcbcrConversionFeatures;
|
|
|
246 using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
|
|
|
247 struct SamplerYcbcrConversionImageFormatProperties;
|
|
|
248 using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
|
|
|
249 struct DeviceGroupRenderPassBeginInfo;
|
|
|
250 using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
|
|
|
251 struct PhysicalDevicePointClippingProperties;
|
|
|
252 using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
|
|
|
253 struct RenderPassInputAttachmentAspectCreateInfo;
|
|
|
254 using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
|
|
|
255 struct InputAttachmentAspectReference;
|
|
|
256 using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
|
|
|
257 struct PipelineTessellationDomainOriginStateCreateInfo;
|
|
|
258 using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
|
|
|
259 struct RenderPassMultiviewCreateInfo;
|
|
|
260 using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
|
|
|
261 struct PhysicalDeviceMultiviewFeatures;
|
|
|
262 using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
|
|
|
263 struct PhysicalDeviceMultiviewProperties;
|
|
|
264 using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
|
|
|
265 struct PhysicalDeviceShaderDrawParametersFeatures;
|
|
|
266 using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
|
|
|
267
|
|
|
268 //=== VK_VERSION_1_2 ===
|
|
|
269 struct PhysicalDeviceVulkan11Features;
|
|
|
270 struct PhysicalDeviceVulkan11Properties;
|
|
|
271 struct PhysicalDeviceVulkan12Features;
|
|
|
272 struct PhysicalDeviceVulkan12Properties;
|
|
|
273 struct ImageFormatListCreateInfo;
|
|
|
274 using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
|
|
|
275 struct ConformanceVersion;
|
|
|
276 using ConformanceVersionKHR = ConformanceVersion;
|
|
|
277 struct PhysicalDeviceDriverProperties;
|
|
|
278 using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
|
|
|
279 struct PhysicalDeviceVulkanMemoryModelFeatures;
|
|
|
280 using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
|
|
|
281 struct PhysicalDeviceHostQueryResetFeatures;
|
|
|
282 using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
|
|
|
283 struct PhysicalDeviceTimelineSemaphoreFeatures;
|
|
|
284 using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
|
|
|
285 struct PhysicalDeviceTimelineSemaphoreProperties;
|
|
|
286 using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
|
|
|
287 struct SemaphoreTypeCreateInfo;
|
|
|
288 using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
|
|
|
289 struct TimelineSemaphoreSubmitInfo;
|
|
|
290 using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
|
|
|
291 struct SemaphoreWaitInfo;
|
|
|
292 using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
|
|
|
293 struct SemaphoreSignalInfo;
|
|
|
294 using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
|
|
|
295 struct PhysicalDeviceBufferDeviceAddressFeatures;
|
|
|
296 using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
|
|
|
297 struct BufferDeviceAddressInfo;
|
|
|
298 using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
|
|
|
299 using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
|
|
|
300 struct BufferOpaqueCaptureAddressCreateInfo;
|
|
|
301 using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
|
|
|
302 struct MemoryOpaqueCaptureAddressAllocateInfo;
|
|
|
303 using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
|
|
|
304 struct DeviceMemoryOpaqueCaptureAddressInfo;
|
|
|
305 using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
|
|
|
306 struct PhysicalDevice8BitStorageFeatures;
|
|
|
307 using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
|
|
|
308 struct PhysicalDeviceShaderAtomicInt64Features;
|
|
|
309 using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
|
|
|
310 struct PhysicalDeviceShaderFloat16Int8Features;
|
|
|
311 using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
|
|
|
312 using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
|
|
|
313 struct PhysicalDeviceFloatControlsProperties;
|
|
|
314 using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
|
|
|
315 struct DescriptorSetLayoutBindingFlagsCreateInfo;
|
|
|
316 using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
|
|
|
317 struct PhysicalDeviceDescriptorIndexingFeatures;
|
|
|
318 using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
|
|
|
319 struct PhysicalDeviceDescriptorIndexingProperties;
|
|
|
320 using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
|
|
|
321 struct DescriptorSetVariableDescriptorCountAllocateInfo;
|
|
|
322 using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
|
|
|
323 struct DescriptorSetVariableDescriptorCountLayoutSupport;
|
|
|
324 using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
|
|
|
325 struct PhysicalDeviceScalarBlockLayoutFeatures;
|
|
|
326 using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
|
|
|
327 struct SamplerReductionModeCreateInfo;
|
|
|
328 using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
|
|
|
329 struct PhysicalDeviceSamplerFilterMinmaxProperties;
|
|
|
330 using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
|
|
|
331 struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
|
|
|
332 using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
|
|
|
333 struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
|
|
|
334 using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
|
|
|
335 struct RenderPassCreateInfo2;
|
|
|
336 using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
|
|
|
337 struct AttachmentDescription2;
|
|
|
338 using AttachmentDescription2KHR = AttachmentDescription2;
|
|
|
339 struct AttachmentReference2;
|
|
|
340 using AttachmentReference2KHR = AttachmentReference2;
|
|
|
341 struct SubpassDescription2;
|
|
|
342 using SubpassDescription2KHR = SubpassDescription2;
|
|
|
343 struct SubpassDependency2;
|
|
|
344 using SubpassDependency2KHR = SubpassDependency2;
|
|
|
345 struct SubpassBeginInfo;
|
|
|
346 using SubpassBeginInfoKHR = SubpassBeginInfo;
|
|
|
347 struct SubpassEndInfo;
|
|
|
348 using SubpassEndInfoKHR = SubpassEndInfo;
|
|
|
349 struct SubpassDescriptionDepthStencilResolve;
|
|
|
350 using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
|
|
|
351 struct PhysicalDeviceDepthStencilResolveProperties;
|
|
|
352 using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
|
|
|
353 struct ImageStencilUsageCreateInfo;
|
|
|
354 using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
|
|
|
355 struct PhysicalDeviceImagelessFramebufferFeatures;
|
|
|
356 using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
|
|
|
357 struct FramebufferAttachmentsCreateInfo;
|
|
|
358 using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
|
|
|
359 struct FramebufferAttachmentImageInfo;
|
|
|
360 using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
|
|
|
361 struct RenderPassAttachmentBeginInfo;
|
|
|
362 using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
|
|
|
363 struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
|
|
|
364 using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
|
|
|
365 struct AttachmentReferenceStencilLayout;
|
|
|
366 using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
|
|
|
367 struct AttachmentDescriptionStencilLayout;
|
|
|
368 using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
|
|
|
369
|
|
|
370 //=== VK_VERSION_1_3 ===
|
|
|
371 struct PhysicalDeviceVulkan13Features;
|
|
|
372 struct PhysicalDeviceVulkan13Properties;
|
|
|
373 struct PhysicalDeviceToolProperties;
|
|
|
374 using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
|
|
|
375 struct PhysicalDevicePrivateDataFeatures;
|
|
|
376 using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
|
|
|
377 struct DevicePrivateDataCreateInfo;
|
|
|
378 using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
|
|
|
379 struct PrivateDataSlotCreateInfo;
|
|
|
380 using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
|
|
|
381 struct MemoryBarrier2;
|
|
|
382 using MemoryBarrier2KHR = MemoryBarrier2;
|
|
|
383 struct BufferMemoryBarrier2;
|
|
|
384 using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
|
|
|
385 struct ImageMemoryBarrier2;
|
|
|
386 using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
|
|
|
387 struct DependencyInfo;
|
|
|
388 using DependencyInfoKHR = DependencyInfo;
|
|
|
389 struct SubmitInfo2;
|
|
|
390 using SubmitInfo2KHR = SubmitInfo2;
|
|
|
391 struct SemaphoreSubmitInfo;
|
|
|
392 using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
|
|
|
393 struct CommandBufferSubmitInfo;
|
|
|
394 using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
|
|
|
395 struct PhysicalDeviceSynchronization2Features;
|
|
|
396 using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
|
|
|
397 struct CopyBufferInfo2;
|
|
|
398 using CopyBufferInfo2KHR = CopyBufferInfo2;
|
|
|
399 struct CopyImageInfo2;
|
|
|
400 using CopyImageInfo2KHR = CopyImageInfo2;
|
|
|
401 struct CopyBufferToImageInfo2;
|
|
|
402 using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
|
|
|
403 struct CopyImageToBufferInfo2;
|
|
|
404 using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
|
|
|
405 struct BufferCopy2;
|
|
|
406 using BufferCopy2KHR = BufferCopy2;
|
|
|
407 struct ImageCopy2;
|
|
|
408 using ImageCopy2KHR = ImageCopy2;
|
|
|
409 struct BufferImageCopy2;
|
|
|
410 using BufferImageCopy2KHR = BufferImageCopy2;
|
|
|
411 struct PhysicalDeviceTextureCompressionASTCHDRFeatures;
|
|
|
412 using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
|
|
|
413 struct FormatProperties3;
|
|
|
414 using FormatProperties3KHR = FormatProperties3;
|
|
|
415 struct PhysicalDeviceMaintenance4Features;
|
|
|
416 using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
|
|
|
417 struct PhysicalDeviceMaintenance4Properties;
|
|
|
418 using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
|
|
|
419 struct DeviceBufferMemoryRequirements;
|
|
|
420 using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
|
|
|
421 struct DeviceImageMemoryRequirements;
|
|
|
422 using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
|
|
|
423 struct PipelineCreationFeedbackCreateInfo;
|
|
|
424 using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
|
|
|
425 struct PipelineCreationFeedback;
|
|
|
426 using PipelineCreationFeedbackEXT = PipelineCreationFeedback;
|
|
|
427 struct PhysicalDeviceShaderTerminateInvocationFeatures;
|
|
|
428 using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;
|
|
|
429 struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
|
|
|
430 using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
|
|
|
431 struct PhysicalDevicePipelineCreationCacheControlFeatures;
|
|
|
432 using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;
|
|
|
433 struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
|
|
|
434 using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
|
|
|
435 struct PhysicalDeviceImageRobustnessFeatures;
|
|
|
436 using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
|
|
|
437 struct PhysicalDeviceSubgroupSizeControlFeatures;
|
|
|
438 using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
|
|
|
439 struct PhysicalDeviceSubgroupSizeControlProperties;
|
|
|
440 using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;
|
|
|
441 struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;
|
|
|
442 using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
|
|
|
443 using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
|
|
|
444 struct PhysicalDeviceInlineUniformBlockFeatures;
|
|
|
445 using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
|
|
|
446 struct PhysicalDeviceInlineUniformBlockProperties;
|
|
|
447 using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
|
|
|
448 struct WriteDescriptorSetInlineUniformBlock;
|
|
|
449 using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
|
|
|
450 struct DescriptorPoolInlineUniformBlockCreateInfo;
|
|
|
451 using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
|
|
|
452 struct PhysicalDeviceShaderIntegerDotProductFeatures;
|
|
|
453 using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;
|
|
|
454 struct PhysicalDeviceShaderIntegerDotProductProperties;
|
|
|
455 using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;
|
|
|
456 struct PhysicalDeviceTexelBufferAlignmentProperties;
|
|
|
457 using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
|
|
|
458 struct BlitImageInfo2;
|
|
|
459 using BlitImageInfo2KHR = BlitImageInfo2;
|
|
|
460 struct ImageBlit2;
|
|
|
461 using ImageBlit2KHR = ImageBlit2;
|
|
|
462 struct ResolveImageInfo2;
|
|
|
463 using ResolveImageInfo2KHR = ResolveImageInfo2;
|
|
|
464 struct ImageResolve2;
|
|
|
465 using ImageResolve2KHR = ImageResolve2;
|
|
|
466 struct RenderingInfo;
|
|
|
467 using RenderingInfoKHR = RenderingInfo;
|
|
|
468 struct RenderingAttachmentInfo;
|
|
|
469 using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
|
|
|
470 struct PipelineRenderingCreateInfo;
|
|
|
471 using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
|
|
|
472 struct PhysicalDeviceDynamicRenderingFeatures;
|
|
|
473 using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
|
|
|
474 struct CommandBufferInheritanceRenderingInfo;
|
|
|
475 using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
|
|
|
476
|
|
|
477 //=== VK_VERSION_1_4 ===
|
|
|
478 struct PhysicalDeviceVulkan14Features;
|
|
|
479 struct PhysicalDeviceVulkan14Properties;
|
|
|
480 struct DeviceQueueGlobalPriorityCreateInfo;
|
|
|
481 using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo;
|
|
|
482 using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo;
|
|
|
483 struct PhysicalDeviceGlobalPriorityQueryFeatures;
|
|
|
484 using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures;
|
|
|
485 using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures;
|
|
|
486 struct QueueFamilyGlobalPriorityProperties;
|
|
|
487 using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties;
|
|
|
488 using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties;
|
|
|
489 struct PhysicalDeviceIndexTypeUint8Features;
|
|
|
490 using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features;
|
|
|
491 using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features;
|
|
|
492 struct MemoryMapInfo;
|
|
|
493 using MemoryMapInfoKHR = MemoryMapInfo;
|
|
|
494 struct MemoryUnmapInfo;
|
|
|
495 using MemoryUnmapInfoKHR = MemoryUnmapInfo;
|
|
|
496 struct PhysicalDeviceMaintenance5Features;
|
|
|
497 using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features;
|
|
|
498 struct PhysicalDeviceMaintenance5Properties;
|
|
|
499 using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties;
|
|
|
500 struct DeviceImageSubresourceInfo;
|
|
|
501 using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo;
|
|
|
502 struct ImageSubresource2;
|
|
|
503 using ImageSubresource2EXT = ImageSubresource2;
|
|
|
504 using ImageSubresource2KHR = ImageSubresource2;
|
|
|
505 struct SubresourceLayout2;
|
|
|
506 using SubresourceLayout2EXT = SubresourceLayout2;
|
|
|
507 using SubresourceLayout2KHR = SubresourceLayout2;
|
|
|
508 struct BufferUsageFlags2CreateInfo;
|
|
|
509 using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo;
|
|
|
510 struct PhysicalDeviceMaintenance6Features;
|
|
|
511 using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features;
|
|
|
512 struct PhysicalDeviceMaintenance6Properties;
|
|
|
513 using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties;
|
|
|
514 struct BindMemoryStatus;
|
|
|
515 using BindMemoryStatusKHR = BindMemoryStatus;
|
|
|
516 struct PhysicalDeviceHostImageCopyFeatures;
|
|
|
517 using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures;
|
|
|
518 struct PhysicalDeviceHostImageCopyProperties;
|
|
|
519 using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties;
|
|
|
520 struct MemoryToImageCopy;
|
|
|
521 using MemoryToImageCopyEXT = MemoryToImageCopy;
|
|
|
522 struct ImageToMemoryCopy;
|
|
|
523 using ImageToMemoryCopyEXT = ImageToMemoryCopy;
|
|
|
524 struct CopyMemoryToImageInfo;
|
|
|
525 using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo;
|
|
|
526 struct CopyImageToMemoryInfo;
|
|
|
527 using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo;
|
|
|
528 struct CopyImageToImageInfo;
|
|
|
529 using CopyImageToImageInfoEXT = CopyImageToImageInfo;
|
|
|
530 struct HostImageLayoutTransitionInfo;
|
|
|
531 using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo;
|
|
|
532 struct SubresourceHostMemcpySize;
|
|
|
533 using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize;
|
|
|
534 struct HostImageCopyDevicePerformanceQuery;
|
|
|
535 using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery;
|
|
|
536 struct PhysicalDeviceShaderSubgroupRotateFeatures;
|
|
|
537 using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures;
|
|
|
538 struct PhysicalDeviceShaderFloatControls2Features;
|
|
|
539 using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features;
|
|
|
540 struct PhysicalDeviceShaderExpectAssumeFeatures;
|
|
|
541 using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures;
|
|
|
542 struct PipelineCreateFlags2CreateInfo;
|
|
|
543 using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo;
|
|
|
544 struct PhysicalDevicePushDescriptorProperties;
|
|
|
545 using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties;
|
|
|
546 struct BindDescriptorSetsInfo;
|
|
|
547 using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo;
|
|
|
548 struct PushConstantsInfo;
|
|
|
549 using PushConstantsInfoKHR = PushConstantsInfo;
|
|
|
550 struct PushDescriptorSetInfo;
|
|
|
551 using PushDescriptorSetInfoKHR = PushDescriptorSetInfo;
|
|
|
552 struct PushDescriptorSetWithTemplateInfo;
|
|
|
553 using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo;
|
|
|
554 struct PhysicalDevicePipelineProtectedAccessFeatures;
|
|
|
555 using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures;
|
|
|
556 struct PhysicalDevicePipelineRobustnessFeatures;
|
|
|
557 using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures;
|
|
|
558 struct PhysicalDevicePipelineRobustnessProperties;
|
|
|
559 using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties;
|
|
|
560 struct PipelineRobustnessCreateInfo;
|
|
|
561 using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo;
|
|
|
562 struct PhysicalDeviceLineRasterizationFeatures;
|
|
|
563 using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures;
|
|
|
564 using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures;
|
|
|
565 struct PhysicalDeviceLineRasterizationProperties;
|
|
|
566 using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties;
|
|
|
567 using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties;
|
|
|
568 struct PipelineRasterizationLineStateCreateInfo;
|
|
|
569 using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo;
|
|
|
570 using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo;
|
|
|
571 struct PhysicalDeviceVertexAttributeDivisorProperties;
|
|
|
572 using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties;
|
|
|
573 struct VertexInputBindingDivisorDescription;
|
|
|
574 using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription;
|
|
|
575 using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription;
|
|
|
576 struct PipelineVertexInputDivisorStateCreateInfo;
|
|
|
577 using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo;
|
|
|
578 using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo;
|
|
|
579 struct PhysicalDeviceVertexAttributeDivisorFeatures;
|
|
|
580 using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures;
|
|
|
581 using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures;
|
|
|
582 struct RenderingAreaInfo;
|
|
|
583 using RenderingAreaInfoKHR = RenderingAreaInfo;
|
|
|
584 struct PhysicalDeviceDynamicRenderingLocalReadFeatures;
|
|
|
585 using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures;
|
|
|
586 struct RenderingAttachmentLocationInfo;
|
|
|
587 using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo;
|
|
|
588 struct RenderingInputAttachmentIndexInfo;
|
|
|
589 using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo;
|
|
|
590
|
|
|
591 //=== VK_KHR_surface ===
|
|
|
592 struct SurfaceCapabilitiesKHR;
|
|
|
593 struct SurfaceFormatKHR;
|
|
|
594
|
|
|
595 //=== VK_KHR_swapchain ===
|
|
|
596 struct SwapchainCreateInfoKHR;
|
|
|
597 struct PresentInfoKHR;
|
|
|
598 struct ImageSwapchainCreateInfoKHR;
|
|
|
599 struct BindImageMemorySwapchainInfoKHR;
|
|
|
600 struct AcquireNextImageInfoKHR;
|
|
|
601 struct DeviceGroupPresentCapabilitiesKHR;
|
|
|
602 struct DeviceGroupPresentInfoKHR;
|
|
|
603 struct DeviceGroupSwapchainCreateInfoKHR;
|
|
|
604
|
|
|
605 //=== VK_KHR_display ===
|
|
|
606 struct DisplayModeCreateInfoKHR;
|
|
|
607 struct DisplayModeParametersKHR;
|
|
|
608 struct DisplayModePropertiesKHR;
|
|
|
609 struct DisplayPlaneCapabilitiesKHR;
|
|
|
610 struct DisplayPlanePropertiesKHR;
|
|
|
611 struct DisplayPropertiesKHR;
|
|
|
612 struct DisplaySurfaceCreateInfoKHR;
|
|
|
613
|
|
|
614 //=== VK_KHR_display_swapchain ===
|
|
|
615 struct DisplayPresentInfoKHR;
|
|
|
616
|
|
|
617 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
618 //=== VK_KHR_xlib_surface ===
|
|
|
619 struct XlibSurfaceCreateInfoKHR;
|
|
|
620 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
621
|
|
|
622 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
623 //=== VK_KHR_xcb_surface ===
|
|
|
624 struct XcbSurfaceCreateInfoKHR;
|
|
|
625 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
626
|
|
|
627 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
628 //=== VK_KHR_wayland_surface ===
|
|
|
629 struct WaylandSurfaceCreateInfoKHR;
|
|
|
630 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
631
|
|
|
632 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
633 //=== VK_KHR_android_surface ===
|
|
|
634 struct AndroidSurfaceCreateInfoKHR;
|
|
|
635 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
636
|
|
|
637 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
638 //=== VK_KHR_win32_surface ===
|
|
|
639 struct Win32SurfaceCreateInfoKHR;
|
|
|
640 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
641
|
|
|
642 //=== VK_EXT_debug_report ===
|
|
|
643 struct DebugReportCallbackCreateInfoEXT;
|
|
|
644
|
|
|
645 //=== VK_AMD_rasterization_order ===
|
|
|
646 struct PipelineRasterizationStateRasterizationOrderAMD;
|
|
|
647
|
|
|
648 //=== VK_EXT_debug_marker ===
|
|
|
649 struct DebugMarkerObjectNameInfoEXT;
|
|
|
650 struct DebugMarkerObjectTagInfoEXT;
|
|
|
651 struct DebugMarkerMarkerInfoEXT;
|
|
|
652
|
|
|
653 //=== VK_KHR_video_queue ===
|
|
|
654 struct QueueFamilyQueryResultStatusPropertiesKHR;
|
|
|
655 struct QueueFamilyVideoPropertiesKHR;
|
|
|
656 struct VideoProfileInfoKHR;
|
|
|
657 struct VideoProfileListInfoKHR;
|
|
|
658 struct VideoCapabilitiesKHR;
|
|
|
659 struct PhysicalDeviceVideoFormatInfoKHR;
|
|
|
660 struct VideoFormatPropertiesKHR;
|
|
|
661 struct VideoPictureResourceInfoKHR;
|
|
|
662 struct VideoReferenceSlotInfoKHR;
|
|
|
663 struct VideoSessionMemoryRequirementsKHR;
|
|
|
664 struct BindVideoSessionMemoryInfoKHR;
|
|
|
665 struct VideoSessionCreateInfoKHR;
|
|
|
666 struct VideoSessionParametersCreateInfoKHR;
|
|
|
667 struct VideoSessionParametersUpdateInfoKHR;
|
|
|
668 struct VideoBeginCodingInfoKHR;
|
|
|
669 struct VideoEndCodingInfoKHR;
|
|
|
670 struct VideoCodingControlInfoKHR;
|
|
|
671
|
|
|
672 //=== VK_KHR_video_decode_queue ===
|
|
|
673 struct VideoDecodeCapabilitiesKHR;
|
|
|
674 struct VideoDecodeUsageInfoKHR;
|
|
|
675 struct VideoDecodeInfoKHR;
|
|
|
676
|
|
|
677 //=== VK_NV_dedicated_allocation ===
|
|
|
678 struct DedicatedAllocationImageCreateInfoNV;
|
|
|
679 struct DedicatedAllocationBufferCreateInfoNV;
|
|
|
680 struct DedicatedAllocationMemoryAllocateInfoNV;
|
|
|
681
|
|
|
682 //=== VK_EXT_transform_feedback ===
|
|
|
683 struct PhysicalDeviceTransformFeedbackFeaturesEXT;
|
|
|
684 struct PhysicalDeviceTransformFeedbackPropertiesEXT;
|
|
|
685 struct PipelineRasterizationStateStreamCreateInfoEXT;
|
|
|
686
|
|
|
687 //=== VK_NVX_binary_import ===
|
|
|
688 struct CuModuleCreateInfoNVX;
|
|
|
689 struct CuModuleTexturingModeCreateInfoNVX;
|
|
|
690 struct CuFunctionCreateInfoNVX;
|
|
|
691 struct CuLaunchInfoNVX;
|
|
|
692
|
|
|
693 //=== VK_NVX_image_view_handle ===
|
|
|
694 struct ImageViewHandleInfoNVX;
|
|
|
695 struct ImageViewAddressPropertiesNVX;
|
|
|
696
|
|
|
697 //=== VK_KHR_video_encode_h264 ===
|
|
|
698 struct VideoEncodeH264CapabilitiesKHR;
|
|
|
699 struct VideoEncodeH264QualityLevelPropertiesKHR;
|
|
|
700 struct VideoEncodeH264SessionCreateInfoKHR;
|
|
|
701 struct VideoEncodeH264SessionParametersCreateInfoKHR;
|
|
|
702 struct VideoEncodeH264SessionParametersAddInfoKHR;
|
|
|
703 struct VideoEncodeH264SessionParametersGetInfoKHR;
|
|
|
704 struct VideoEncodeH264SessionParametersFeedbackInfoKHR;
|
|
|
705 struct VideoEncodeH264PictureInfoKHR;
|
|
|
706 struct VideoEncodeH264DpbSlotInfoKHR;
|
|
|
707 struct VideoEncodeH264NaluSliceInfoKHR;
|
|
|
708 struct VideoEncodeH264ProfileInfoKHR;
|
|
|
709 struct VideoEncodeH264RateControlInfoKHR;
|
|
|
710 struct VideoEncodeH264RateControlLayerInfoKHR;
|
|
|
711 struct VideoEncodeH264QpKHR;
|
|
|
712 struct VideoEncodeH264FrameSizeKHR;
|
|
|
713 struct VideoEncodeH264GopRemainingFrameInfoKHR;
|
|
|
714
|
|
|
715 //=== VK_KHR_video_encode_h265 ===
|
|
|
716 struct VideoEncodeH265CapabilitiesKHR;
|
|
|
717 struct VideoEncodeH265SessionCreateInfoKHR;
|
|
|
718 struct VideoEncodeH265QualityLevelPropertiesKHR;
|
|
|
719 struct VideoEncodeH265SessionParametersCreateInfoKHR;
|
|
|
720 struct VideoEncodeH265SessionParametersAddInfoKHR;
|
|
|
721 struct VideoEncodeH265SessionParametersGetInfoKHR;
|
|
|
722 struct VideoEncodeH265SessionParametersFeedbackInfoKHR;
|
|
|
723 struct VideoEncodeH265PictureInfoKHR;
|
|
|
724 struct VideoEncodeH265DpbSlotInfoKHR;
|
|
|
725 struct VideoEncodeH265NaluSliceSegmentInfoKHR;
|
|
|
726 struct VideoEncodeH265ProfileInfoKHR;
|
|
|
727 struct VideoEncodeH265RateControlInfoKHR;
|
|
|
728 struct VideoEncodeH265RateControlLayerInfoKHR;
|
|
|
729 struct VideoEncodeH265QpKHR;
|
|
|
730 struct VideoEncodeH265FrameSizeKHR;
|
|
|
731 struct VideoEncodeH265GopRemainingFrameInfoKHR;
|
|
|
732
|
|
|
733 //=== VK_KHR_video_decode_h264 ===
|
|
|
734 struct VideoDecodeH264ProfileInfoKHR;
|
|
|
735 struct VideoDecodeH264CapabilitiesKHR;
|
|
|
736 struct VideoDecodeH264SessionParametersCreateInfoKHR;
|
|
|
737 struct VideoDecodeH264SessionParametersAddInfoKHR;
|
|
|
738 struct VideoDecodeH264PictureInfoKHR;
|
|
|
739 struct VideoDecodeH264DpbSlotInfoKHR;
|
|
|
740
|
|
|
741 //=== VK_AMD_texture_gather_bias_lod ===
|
|
|
742 struct TextureLODGatherFormatPropertiesAMD;
|
|
|
743
|
|
|
744 //=== VK_AMD_shader_info ===
|
|
|
745 struct ShaderResourceUsageAMD;
|
|
|
746 struct ShaderStatisticsInfoAMD;
|
|
|
747
|
|
|
748 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
749 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
750 struct StreamDescriptorSurfaceCreateInfoGGP;
|
|
|
751 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
752
|
|
|
753 //=== VK_NV_corner_sampled_image ===
|
|
|
754 struct PhysicalDeviceCornerSampledImageFeaturesNV;
|
|
|
755
|
|
|
756 //=== VK_NV_external_memory_capabilities ===
|
|
|
757 struct ExternalImageFormatPropertiesNV;
|
|
|
758
|
|
|
759 //=== VK_NV_external_memory ===
|
|
|
760 struct ExternalMemoryImageCreateInfoNV;
|
|
|
761 struct ExportMemoryAllocateInfoNV;
|
|
|
762
|
|
|
763 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
764 //=== VK_NV_external_memory_win32 ===
|
|
|
765 struct ImportMemoryWin32HandleInfoNV;
|
|
|
766 struct ExportMemoryWin32HandleInfoNV;
|
|
|
767 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
768
|
|
|
769 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
770 //=== VK_NV_win32_keyed_mutex ===
|
|
|
771 struct Win32KeyedMutexAcquireReleaseInfoNV;
|
|
|
772 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
773
|
|
|
774 //=== VK_EXT_validation_flags ===
|
|
|
775 struct ValidationFlagsEXT;
|
|
|
776
|
|
|
777 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
778 //=== VK_NN_vi_surface ===
|
|
|
779 struct ViSurfaceCreateInfoNN;
|
|
|
780 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
781
|
|
|
782 //=== VK_EXT_astc_decode_mode ===
|
|
|
783 struct ImageViewASTCDecodeModeEXT;
|
|
|
784 struct PhysicalDeviceASTCDecodeFeaturesEXT;
|
|
|
785
|
|
|
786 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
787 //=== VK_KHR_external_memory_win32 ===
|
|
|
788 struct ImportMemoryWin32HandleInfoKHR;
|
|
|
789 struct ExportMemoryWin32HandleInfoKHR;
|
|
|
790 struct MemoryWin32HandlePropertiesKHR;
|
|
|
791 struct MemoryGetWin32HandleInfoKHR;
|
|
|
792 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
793
|
|
|
794 //=== VK_KHR_external_memory_fd ===
|
|
|
795 struct ImportMemoryFdInfoKHR;
|
|
|
796 struct MemoryFdPropertiesKHR;
|
|
|
797 struct MemoryGetFdInfoKHR;
|
|
|
798
|
|
|
799 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
800 //=== VK_KHR_win32_keyed_mutex ===
|
|
|
801 struct Win32KeyedMutexAcquireReleaseInfoKHR;
|
|
|
802 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
803
|
|
|
804 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
805 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
806 struct ImportSemaphoreWin32HandleInfoKHR;
|
|
|
807 struct ExportSemaphoreWin32HandleInfoKHR;
|
|
|
808 struct D3D12FenceSubmitInfoKHR;
|
|
|
809 struct SemaphoreGetWin32HandleInfoKHR;
|
|
|
810 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
811
|
|
|
812 //=== VK_KHR_external_semaphore_fd ===
|
|
|
813 struct ImportSemaphoreFdInfoKHR;
|
|
|
814 struct SemaphoreGetFdInfoKHR;
|
|
|
815
|
|
|
816 //=== VK_EXT_conditional_rendering ===
|
|
|
817 struct ConditionalRenderingBeginInfoEXT;
|
|
|
818 struct PhysicalDeviceConditionalRenderingFeaturesEXT;
|
|
|
819 struct CommandBufferInheritanceConditionalRenderingInfoEXT;
|
|
|
820
|
|
|
821 //=== VK_KHR_incremental_present ===
|
|
|
822 struct PresentRegionsKHR;
|
|
|
823 struct PresentRegionKHR;
|
|
|
824 struct RectLayerKHR;
|
|
|
825
|
|
|
826 //=== VK_NV_clip_space_w_scaling ===
|
|
|
827 struct ViewportWScalingNV;
|
|
|
828 struct PipelineViewportWScalingStateCreateInfoNV;
|
|
|
829
|
|
|
830 //=== VK_EXT_display_surface_counter ===
|
|
|
831 struct SurfaceCapabilities2EXT;
|
|
|
832
|
|
|
833 //=== VK_EXT_display_control ===
|
|
|
834 struct DisplayPowerInfoEXT;
|
|
|
835 struct DeviceEventInfoEXT;
|
|
|
836 struct DisplayEventInfoEXT;
|
|
|
837 struct SwapchainCounterCreateInfoEXT;
|
|
|
838
|
|
|
839 //=== VK_GOOGLE_display_timing ===
|
|
|
840 struct RefreshCycleDurationGOOGLE;
|
|
|
841 struct PastPresentationTimingGOOGLE;
|
|
|
842 struct PresentTimesInfoGOOGLE;
|
|
|
843 struct PresentTimeGOOGLE;
|
|
|
844
|
|
|
845 //=== VK_NVX_multiview_per_view_attributes ===
|
|
|
846 struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
|
|
|
847 struct MultiviewPerViewAttributesInfoNVX;
|
|
|
848
|
|
|
849 //=== VK_NV_viewport_swizzle ===
|
|
|
850 struct ViewportSwizzleNV;
|
|
|
851 struct PipelineViewportSwizzleStateCreateInfoNV;
|
|
|
852
|
|
|
853 //=== VK_EXT_discard_rectangles ===
|
|
|
854 struct PhysicalDeviceDiscardRectanglePropertiesEXT;
|
|
|
855 struct PipelineDiscardRectangleStateCreateInfoEXT;
|
|
|
856
|
|
|
857 //=== VK_EXT_conservative_rasterization ===
|
|
|
858 struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
|
|
|
859 struct PipelineRasterizationConservativeStateCreateInfoEXT;
|
|
|
860
|
|
|
861 //=== VK_EXT_depth_clip_enable ===
|
|
|
862 struct PhysicalDeviceDepthClipEnableFeaturesEXT;
|
|
|
863 struct PipelineRasterizationDepthClipStateCreateInfoEXT;
|
|
|
864
|
|
|
865 //=== VK_EXT_hdr_metadata ===
|
|
|
866 struct HdrMetadataEXT;
|
|
|
867 struct XYColorEXT;
|
|
|
868
|
|
|
869 //=== VK_IMG_relaxed_line_rasterization ===
|
|
|
870 struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
|
|
|
871
|
|
|
872 //=== VK_KHR_shared_presentable_image ===
|
|
|
873 struct SharedPresentSurfaceCapabilitiesKHR;
|
|
|
874
|
|
|
875 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
876 //=== VK_KHR_external_fence_win32 ===
|
|
|
877 struct ImportFenceWin32HandleInfoKHR;
|
|
|
878 struct ExportFenceWin32HandleInfoKHR;
|
|
|
879 struct FenceGetWin32HandleInfoKHR;
|
|
|
880 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
881
|
|
|
882 //=== VK_KHR_external_fence_fd ===
|
|
|
883 struct ImportFenceFdInfoKHR;
|
|
|
884 struct FenceGetFdInfoKHR;
|
|
|
885
|
|
|
886 //=== VK_KHR_performance_query ===
|
|
|
887 struct PhysicalDevicePerformanceQueryFeaturesKHR;
|
|
|
888 struct PhysicalDevicePerformanceQueryPropertiesKHR;
|
|
|
889 struct PerformanceCounterKHR;
|
|
|
890 struct PerformanceCounterDescriptionKHR;
|
|
|
891 struct QueryPoolPerformanceCreateInfoKHR;
|
|
|
892 union PerformanceCounterResultKHR;
|
|
|
893 struct AcquireProfilingLockInfoKHR;
|
|
|
894 struct PerformanceQuerySubmitInfoKHR;
|
|
|
895
|
|
|
896 //=== VK_KHR_get_surface_capabilities2 ===
|
|
|
897 struct PhysicalDeviceSurfaceInfo2KHR;
|
|
|
898 struct SurfaceCapabilities2KHR;
|
|
|
899 struct SurfaceFormat2KHR;
|
|
|
900
|
|
|
901 //=== VK_KHR_get_display_properties2 ===
|
|
|
902 struct DisplayProperties2KHR;
|
|
|
903 struct DisplayPlaneProperties2KHR;
|
|
|
904 struct DisplayModeProperties2KHR;
|
|
|
905 struct DisplayPlaneInfo2KHR;
|
|
|
906 struct DisplayPlaneCapabilities2KHR;
|
|
|
907
|
|
|
908 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
909 //=== VK_MVK_ios_surface ===
|
|
|
910 struct IOSSurfaceCreateInfoMVK;
|
|
|
911 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
912
|
|
|
913 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
914 //=== VK_MVK_macos_surface ===
|
|
|
915 struct MacOSSurfaceCreateInfoMVK;
|
|
|
916 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
917
|
|
|
918 //=== VK_EXT_debug_utils ===
|
|
|
919 struct DebugUtilsLabelEXT;
|
|
|
920 struct DebugUtilsMessengerCallbackDataEXT;
|
|
|
921 struct DebugUtilsMessengerCreateInfoEXT;
|
|
|
922 struct DebugUtilsObjectNameInfoEXT;
|
|
|
923 struct DebugUtilsObjectTagInfoEXT;
|
|
|
924
|
|
|
925 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
926 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
927 struct AndroidHardwareBufferUsageANDROID;
|
|
|
928 struct AndroidHardwareBufferPropertiesANDROID;
|
|
|
929 struct AndroidHardwareBufferFormatPropertiesANDROID;
|
|
|
930 struct ImportAndroidHardwareBufferInfoANDROID;
|
|
|
931 struct MemoryGetAndroidHardwareBufferInfoANDROID;
|
|
|
932 struct ExternalFormatANDROID;
|
|
|
933 struct AndroidHardwareBufferFormatProperties2ANDROID;
|
|
|
934 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
935
|
|
|
936 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
937 //=== VK_AMDX_shader_enqueue ===
|
|
|
938 struct PhysicalDeviceShaderEnqueueFeaturesAMDX;
|
|
|
939 struct PhysicalDeviceShaderEnqueuePropertiesAMDX;
|
|
|
940 struct ExecutionGraphPipelineScratchSizeAMDX;
|
|
|
941 struct ExecutionGraphPipelineCreateInfoAMDX;
|
|
|
942 struct DispatchGraphInfoAMDX;
|
|
|
943 struct DispatchGraphCountInfoAMDX;
|
|
|
944 struct PipelineShaderStageNodeCreateInfoAMDX;
|
|
|
945 union DeviceOrHostAddressConstAMDX;
|
|
|
946 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
947
|
|
|
948 //=== VK_AMD_mixed_attachment_samples ===
|
|
|
949 struct AttachmentSampleCountInfoAMD;
|
|
|
950 using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
|
|
|
951
|
|
|
952 //=== VK_KHR_shader_bfloat16 ===
|
|
|
953 struct PhysicalDeviceShaderBfloat16FeaturesKHR;
|
|
|
954
|
|
|
955 //=== VK_EXT_sample_locations ===
|
|
|
956 struct SampleLocationEXT;
|
|
|
957 struct SampleLocationsInfoEXT;
|
|
|
958 struct AttachmentSampleLocationsEXT;
|
|
|
959 struct SubpassSampleLocationsEXT;
|
|
|
960 struct RenderPassSampleLocationsBeginInfoEXT;
|
|
|
961 struct PipelineSampleLocationsStateCreateInfoEXT;
|
|
|
962 struct PhysicalDeviceSampleLocationsPropertiesEXT;
|
|
|
963 struct MultisamplePropertiesEXT;
|
|
|
964
|
|
|
965 //=== VK_EXT_blend_operation_advanced ===
|
|
|
966 struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
|
|
|
967 struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
|
|
|
968 struct PipelineColorBlendAdvancedStateCreateInfoEXT;
|
|
|
969
|
|
|
970 //=== VK_NV_fragment_coverage_to_color ===
|
|
|
971 struct PipelineCoverageToColorStateCreateInfoNV;
|
|
|
972
|
|
|
973 //=== VK_KHR_acceleration_structure ===
|
|
|
974 union DeviceOrHostAddressKHR;
|
|
|
975 union DeviceOrHostAddressConstKHR;
|
|
|
976 struct AccelerationStructureBuildRangeInfoKHR;
|
|
|
977 struct AabbPositionsKHR;
|
|
|
978 using AabbPositionsNV = AabbPositionsKHR;
|
|
|
979 struct AccelerationStructureGeometryTrianglesDataKHR;
|
|
|
980 struct TransformMatrixKHR;
|
|
|
981 using TransformMatrixNV = TransformMatrixKHR;
|
|
|
982 struct AccelerationStructureBuildGeometryInfoKHR;
|
|
|
983 struct AccelerationStructureGeometryAabbsDataKHR;
|
|
|
984 struct AccelerationStructureInstanceKHR;
|
|
|
985 using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
|
|
|
986 struct AccelerationStructureGeometryInstancesDataKHR;
|
|
|
987 union AccelerationStructureGeometryDataKHR;
|
|
|
988 struct AccelerationStructureGeometryKHR;
|
|
|
989 struct AccelerationStructureCreateInfoKHR;
|
|
|
990 struct WriteDescriptorSetAccelerationStructureKHR;
|
|
|
991 struct PhysicalDeviceAccelerationStructureFeaturesKHR;
|
|
|
992 struct PhysicalDeviceAccelerationStructurePropertiesKHR;
|
|
|
993 struct AccelerationStructureDeviceAddressInfoKHR;
|
|
|
994 struct AccelerationStructureVersionInfoKHR;
|
|
|
995 struct CopyAccelerationStructureToMemoryInfoKHR;
|
|
|
996 struct CopyMemoryToAccelerationStructureInfoKHR;
|
|
|
997 struct CopyAccelerationStructureInfoKHR;
|
|
|
998 struct AccelerationStructureBuildSizesInfoKHR;
|
|
|
999
|
|
|
1000 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
1001 struct RayTracingShaderGroupCreateInfoKHR;
|
|
|
1002 struct RayTracingPipelineCreateInfoKHR;
|
|
|
1003 struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
|
|
|
1004 struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
|
|
|
1005 struct StridedDeviceAddressRegionKHR;
|
|
|
1006 struct TraceRaysIndirectCommandKHR;
|
|
|
1007 struct RayTracingPipelineInterfaceCreateInfoKHR;
|
|
|
1008
|
|
|
1009 //=== VK_KHR_ray_query ===
|
|
|
1010 struct PhysicalDeviceRayQueryFeaturesKHR;
|
|
|
1011
|
|
|
1012 //=== VK_NV_framebuffer_mixed_samples ===
|
|
|
1013 struct PipelineCoverageModulationStateCreateInfoNV;
|
|
|
1014
|
|
|
1015 //=== VK_NV_shader_sm_builtins ===
|
|
|
1016 struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
|
|
|
1017 struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
|
|
|
1018
|
|
|
1019 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
1020 struct DrmFormatModifierPropertiesListEXT;
|
|
|
1021 struct DrmFormatModifierPropertiesEXT;
|
|
|
1022 struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
|
|
|
1023 struct ImageDrmFormatModifierListCreateInfoEXT;
|
|
|
1024 struct ImageDrmFormatModifierExplicitCreateInfoEXT;
|
|
|
1025 struct ImageDrmFormatModifierPropertiesEXT;
|
|
|
1026 struct DrmFormatModifierPropertiesList2EXT;
|
|
|
1027 struct DrmFormatModifierProperties2EXT;
|
|
|
1028
|
|
|
1029 //=== VK_EXT_validation_cache ===
|
|
|
1030 struct ValidationCacheCreateInfoEXT;
|
|
|
1031 struct ShaderModuleValidationCacheCreateInfoEXT;
|
|
|
1032
|
|
|
1033 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
1034 //=== VK_KHR_portability_subset ===
|
|
|
1035 struct PhysicalDevicePortabilitySubsetFeaturesKHR;
|
|
|
1036 struct PhysicalDevicePortabilitySubsetPropertiesKHR;
|
|
|
1037 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
1038
|
|
|
1039 //=== VK_NV_shading_rate_image ===
|
|
|
1040 struct ShadingRatePaletteNV;
|
|
|
1041 struct PipelineViewportShadingRateImageStateCreateInfoNV;
|
|
|
1042 struct PhysicalDeviceShadingRateImageFeaturesNV;
|
|
|
1043 struct PhysicalDeviceShadingRateImagePropertiesNV;
|
|
|
1044 struct CoarseSampleLocationNV;
|
|
|
1045 struct CoarseSampleOrderCustomNV;
|
|
|
1046 struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
|
|
|
1047
|
|
|
1048 //=== VK_NV_ray_tracing ===
|
|
|
1049 struct RayTracingShaderGroupCreateInfoNV;
|
|
|
1050 struct RayTracingPipelineCreateInfoNV;
|
|
|
1051 struct GeometryTrianglesNV;
|
|
|
1052 struct GeometryAABBNV;
|
|
|
1053 struct GeometryDataNV;
|
|
|
1054 struct GeometryNV;
|
|
|
1055 struct AccelerationStructureInfoNV;
|
|
|
1056 struct AccelerationStructureCreateInfoNV;
|
|
|
1057 struct BindAccelerationStructureMemoryInfoNV;
|
|
|
1058 struct WriteDescriptorSetAccelerationStructureNV;
|
|
|
1059 struct AccelerationStructureMemoryRequirementsInfoNV;
|
|
|
1060 struct PhysicalDeviceRayTracingPropertiesNV;
|
|
|
1061
|
|
|
1062 //=== VK_NV_representative_fragment_test ===
|
|
|
1063 struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
|
|
|
1064 struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
|
|
|
1065
|
|
|
1066 //=== VK_EXT_filter_cubic ===
|
|
|
1067 struct PhysicalDeviceImageViewImageFormatInfoEXT;
|
|
|
1068 struct FilterCubicImageViewImageFormatPropertiesEXT;
|
|
|
1069
|
|
|
1070 //=== VK_EXT_external_memory_host ===
|
|
|
1071 struct ImportMemoryHostPointerInfoEXT;
|
|
|
1072 struct MemoryHostPointerPropertiesEXT;
|
|
|
1073 struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
|
|
|
1074
|
|
|
1075 //=== VK_KHR_shader_clock ===
|
|
|
1076 struct PhysicalDeviceShaderClockFeaturesKHR;
|
|
|
1077
|
|
|
1078 //=== VK_AMD_pipeline_compiler_control ===
|
|
|
1079 struct PipelineCompilerControlCreateInfoAMD;
|
|
|
1080
|
|
|
1081 //=== VK_AMD_shader_core_properties ===
|
|
|
1082 struct PhysicalDeviceShaderCorePropertiesAMD;
|
|
|
1083
|
|
|
1084 //=== VK_KHR_video_decode_h265 ===
|
|
|
1085 struct VideoDecodeH265ProfileInfoKHR;
|
|
|
1086 struct VideoDecodeH265CapabilitiesKHR;
|
|
|
1087 struct VideoDecodeH265SessionParametersCreateInfoKHR;
|
|
|
1088 struct VideoDecodeH265SessionParametersAddInfoKHR;
|
|
|
1089 struct VideoDecodeH265PictureInfoKHR;
|
|
|
1090 struct VideoDecodeH265DpbSlotInfoKHR;
|
|
|
1091
|
|
|
1092 //=== VK_AMD_memory_overallocation_behavior ===
|
|
|
1093 struct DeviceMemoryOverallocationCreateInfoAMD;
|
|
|
1094
|
|
|
1095 //=== VK_EXT_vertex_attribute_divisor ===
|
|
|
1096 struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
|
|
|
1097
|
|
|
1098 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
1099 //=== VK_GGP_frame_token ===
|
|
|
1100 struct PresentFrameTokenGGP;
|
|
|
1101 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
1102
|
|
|
1103 //=== VK_NV_mesh_shader ===
|
|
|
1104 struct PhysicalDeviceMeshShaderFeaturesNV;
|
|
|
1105 struct PhysicalDeviceMeshShaderPropertiesNV;
|
|
|
1106 struct DrawMeshTasksIndirectCommandNV;
|
|
|
1107
|
|
|
1108 //=== VK_NV_shader_image_footprint ===
|
|
|
1109 struct PhysicalDeviceShaderImageFootprintFeaturesNV;
|
|
|
1110
|
|
|
1111 //=== VK_NV_scissor_exclusive ===
|
|
|
1112 struct PipelineViewportExclusiveScissorStateCreateInfoNV;
|
|
|
1113 struct PhysicalDeviceExclusiveScissorFeaturesNV;
|
|
|
1114
|
|
|
1115 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
1116 struct QueueFamilyCheckpointPropertiesNV;
|
|
|
1117 struct CheckpointDataNV;
|
|
|
1118 struct QueueFamilyCheckpointProperties2NV;
|
|
|
1119 struct CheckpointData2NV;
|
|
|
1120
|
|
|
1121 //=== VK_INTEL_shader_integer_functions2 ===
|
|
|
1122 struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
|
|
|
1123
|
|
|
1124 //=== VK_INTEL_performance_query ===
|
|
|
1125 union PerformanceValueDataINTEL;
|
|
|
1126 struct PerformanceValueINTEL;
|
|
|
1127 struct InitializePerformanceApiInfoINTEL;
|
|
|
1128 struct QueryPoolPerformanceQueryCreateInfoINTEL;
|
|
|
1129 using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
|
|
|
1130 struct PerformanceMarkerInfoINTEL;
|
|
|
1131 struct PerformanceStreamMarkerInfoINTEL;
|
|
|
1132 struct PerformanceOverrideInfoINTEL;
|
|
|
1133 struct PerformanceConfigurationAcquireInfoINTEL;
|
|
|
1134
|
|
|
1135 //=== VK_EXT_pci_bus_info ===
|
|
|
1136 struct PhysicalDevicePCIBusInfoPropertiesEXT;
|
|
|
1137
|
|
|
1138 //=== VK_AMD_display_native_hdr ===
|
|
|
1139 struct DisplayNativeHdrSurfaceCapabilitiesAMD;
|
|
|
1140 struct SwapchainDisplayNativeHdrCreateInfoAMD;
|
|
|
1141
|
|
|
1142 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
1143 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
1144 struct ImagePipeSurfaceCreateInfoFUCHSIA;
|
|
|
1145 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
1146
|
|
|
1147 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
1148 //=== VK_EXT_metal_surface ===
|
|
|
1149 struct MetalSurfaceCreateInfoEXT;
|
|
|
1150 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
1151
|
|
|
1152 //=== VK_EXT_fragment_density_map ===
|
|
|
1153 struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
|
|
|
1154 struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
|
|
|
1155 struct RenderPassFragmentDensityMapCreateInfoEXT;
|
|
|
1156 struct RenderingFragmentDensityMapAttachmentInfoEXT;
|
|
|
1157
|
|
|
1158 //=== VK_KHR_fragment_shading_rate ===
|
|
|
1159 struct FragmentShadingRateAttachmentInfoKHR;
|
|
|
1160 struct PipelineFragmentShadingRateStateCreateInfoKHR;
|
|
|
1161 struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
|
|
|
1162 struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
|
|
|
1163 struct PhysicalDeviceFragmentShadingRateKHR;
|
|
|
1164 struct RenderingFragmentShadingRateAttachmentInfoKHR;
|
|
|
1165
|
|
|
1166 //=== VK_AMD_shader_core_properties2 ===
|
|
|
1167 struct PhysicalDeviceShaderCoreProperties2AMD;
|
|
|
1168
|
|
|
1169 //=== VK_AMD_device_coherent_memory ===
|
|
|
1170 struct PhysicalDeviceCoherentMemoryFeaturesAMD;
|
|
|
1171
|
|
|
1172 //=== VK_EXT_shader_image_atomic_int64 ===
|
|
|
1173 struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
|
|
|
1174
|
|
|
1175 //=== VK_KHR_shader_quad_control ===
|
|
|
1176 struct PhysicalDeviceShaderQuadControlFeaturesKHR;
|
|
|
1177
|
|
|
1178 //=== VK_EXT_memory_budget ===
|
|
|
1179 struct PhysicalDeviceMemoryBudgetPropertiesEXT;
|
|
|
1180
|
|
|
1181 //=== VK_EXT_memory_priority ===
|
|
|
1182 struct PhysicalDeviceMemoryPriorityFeaturesEXT;
|
|
|
1183 struct MemoryPriorityAllocateInfoEXT;
|
|
|
1184
|
|
|
1185 //=== VK_KHR_surface_protected_capabilities ===
|
|
|
1186 struct SurfaceProtectedCapabilitiesKHR;
|
|
|
1187
|
|
|
1188 //=== VK_NV_dedicated_allocation_image_aliasing ===
|
|
|
1189 struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
|
|
|
1190
|
|
|
1191 //=== VK_EXT_buffer_device_address ===
|
|
|
1192 struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
|
|
|
1193 using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
|
|
|
1194 struct BufferDeviceAddressCreateInfoEXT;
|
|
|
1195
|
|
|
1196 //=== VK_EXT_validation_features ===
|
|
|
1197 struct ValidationFeaturesEXT;
|
|
|
1198
|
|
|
1199 //=== VK_KHR_present_wait ===
|
|
|
1200 struct PhysicalDevicePresentWaitFeaturesKHR;
|
|
|
1201
|
|
|
1202 //=== VK_NV_cooperative_matrix ===
|
|
|
1203 struct CooperativeMatrixPropertiesNV;
|
|
|
1204 struct PhysicalDeviceCooperativeMatrixFeaturesNV;
|
|
|
1205 struct PhysicalDeviceCooperativeMatrixPropertiesNV;
|
|
|
1206
|
|
|
1207 //=== VK_NV_coverage_reduction_mode ===
|
|
|
1208 struct PhysicalDeviceCoverageReductionModeFeaturesNV;
|
|
|
1209 struct PipelineCoverageReductionStateCreateInfoNV;
|
|
|
1210 struct FramebufferMixedSamplesCombinationNV;
|
|
|
1211
|
|
|
1212 //=== VK_EXT_fragment_shader_interlock ===
|
|
|
1213 struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
|
|
|
1214
|
|
|
1215 //=== VK_EXT_ycbcr_image_arrays ===
|
|
|
1216 struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
|
|
|
1217
|
|
|
1218 //=== VK_EXT_provoking_vertex ===
|
|
|
1219 struct PhysicalDeviceProvokingVertexFeaturesEXT;
|
|
|
1220 struct PhysicalDeviceProvokingVertexPropertiesEXT;
|
|
|
1221 struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
|
|
|
1222
|
|
|
1223 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
1224 //=== VK_EXT_full_screen_exclusive ===
|
|
|
1225 struct SurfaceFullScreenExclusiveInfoEXT;
|
|
|
1226 struct SurfaceCapabilitiesFullScreenExclusiveEXT;
|
|
|
1227 struct SurfaceFullScreenExclusiveWin32InfoEXT;
|
|
|
1228 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
1229
|
|
|
1230 //=== VK_EXT_headless_surface ===
|
|
|
1231 struct HeadlessSurfaceCreateInfoEXT;
|
|
|
1232
|
|
|
1233 //=== VK_EXT_shader_atomic_float ===
|
|
|
1234 struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
|
|
|
1235
|
|
|
1236 //=== VK_EXT_extended_dynamic_state ===
|
|
|
1237 struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
|
|
|
1238
|
|
|
1239 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
1240 struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
|
|
|
1241 struct PipelineInfoKHR;
|
|
|
1242 using PipelineInfoEXT = PipelineInfoKHR;
|
|
|
1243 struct PipelineExecutablePropertiesKHR;
|
|
|
1244 struct PipelineExecutableInfoKHR;
|
|
|
1245 union PipelineExecutableStatisticValueKHR;
|
|
|
1246 struct PipelineExecutableStatisticKHR;
|
|
|
1247 struct PipelineExecutableInternalRepresentationKHR;
|
|
|
1248
|
|
|
1249 //=== VK_EXT_map_memory_placed ===
|
|
|
1250 struct PhysicalDeviceMapMemoryPlacedFeaturesEXT;
|
|
|
1251 struct PhysicalDeviceMapMemoryPlacedPropertiesEXT;
|
|
|
1252 struct MemoryMapPlacedInfoEXT;
|
|
|
1253
|
|
|
1254 //=== VK_EXT_shader_atomic_float2 ===
|
|
|
1255 struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
|
|
|
1256
|
|
|
1257 //=== VK_NV_device_generated_commands ===
|
|
|
1258 struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
|
|
|
1259 struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
|
|
|
1260 struct GraphicsShaderGroupCreateInfoNV;
|
|
|
1261 struct GraphicsPipelineShaderGroupsCreateInfoNV;
|
|
|
1262 struct BindShaderGroupIndirectCommandNV;
|
|
|
1263 struct BindIndexBufferIndirectCommandNV;
|
|
|
1264 struct BindVertexBufferIndirectCommandNV;
|
|
|
1265 struct SetStateFlagsIndirectCommandNV;
|
|
|
1266 struct IndirectCommandsStreamNV;
|
|
|
1267 struct IndirectCommandsLayoutTokenNV;
|
|
|
1268 struct IndirectCommandsLayoutCreateInfoNV;
|
|
|
1269 struct GeneratedCommandsInfoNV;
|
|
|
1270 struct GeneratedCommandsMemoryRequirementsInfoNV;
|
|
|
1271
|
|
|
1272 //=== VK_NV_inherited_viewport_scissor ===
|
|
|
1273 struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
|
|
|
1274 struct CommandBufferInheritanceViewportScissorInfoNV;
|
|
|
1275
|
|
|
1276 //=== VK_EXT_texel_buffer_alignment ===
|
|
|
1277 struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
|
|
|
1278
|
|
|
1279 //=== VK_QCOM_render_pass_transform ===
|
|
|
1280 struct RenderPassTransformBeginInfoQCOM;
|
|
|
1281 struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
|
|
|
1282
|
|
|
1283 //=== VK_EXT_depth_bias_control ===
|
|
|
1284 struct PhysicalDeviceDepthBiasControlFeaturesEXT;
|
|
|
1285 struct DepthBiasInfoEXT;
|
|
|
1286 struct DepthBiasRepresentationInfoEXT;
|
|
|
1287
|
|
|
1288 //=== VK_EXT_device_memory_report ===
|
|
|
1289 struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
|
|
|
1290 struct DeviceDeviceMemoryReportCreateInfoEXT;
|
|
|
1291 struct DeviceMemoryReportCallbackDataEXT;
|
|
|
1292
|
|
|
1293 //=== VK_EXT_custom_border_color ===
|
|
|
1294 struct SamplerCustomBorderColorCreateInfoEXT;
|
|
|
1295 struct PhysicalDeviceCustomBorderColorPropertiesEXT;
|
|
|
1296 struct PhysicalDeviceCustomBorderColorFeaturesEXT;
|
|
|
1297
|
|
|
1298 //=== VK_KHR_pipeline_library ===
|
|
|
1299 struct PipelineLibraryCreateInfoKHR;
|
|
|
1300
|
|
|
1301 //=== VK_NV_present_barrier ===
|
|
|
1302 struct PhysicalDevicePresentBarrierFeaturesNV;
|
|
|
1303 struct SurfaceCapabilitiesPresentBarrierNV;
|
|
|
1304 struct SwapchainPresentBarrierCreateInfoNV;
|
|
|
1305
|
|
|
1306 //=== VK_KHR_present_id ===
|
|
|
1307 struct PresentIdKHR;
|
|
|
1308 struct PhysicalDevicePresentIdFeaturesKHR;
|
|
|
1309
|
|
|
1310 //=== VK_KHR_video_encode_queue ===
|
|
|
1311 struct VideoEncodeInfoKHR;
|
|
|
1312 struct VideoEncodeCapabilitiesKHR;
|
|
|
1313 struct QueryPoolVideoEncodeFeedbackCreateInfoKHR;
|
|
|
1314 struct VideoEncodeUsageInfoKHR;
|
|
|
1315 struct VideoEncodeRateControlInfoKHR;
|
|
|
1316 struct VideoEncodeRateControlLayerInfoKHR;
|
|
|
1317 struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
|
|
|
1318 struct VideoEncodeQualityLevelPropertiesKHR;
|
|
|
1319 struct VideoEncodeQualityLevelInfoKHR;
|
|
|
1320 struct VideoEncodeSessionParametersGetInfoKHR;
|
|
|
1321 struct VideoEncodeSessionParametersFeedbackInfoKHR;
|
|
|
1322
|
|
|
1323 //=== VK_NV_device_diagnostics_config ===
|
|
|
1324 struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
|
|
|
1325 struct DeviceDiagnosticsConfigCreateInfoNV;
|
|
|
1326
|
|
|
1327 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
1328 //=== VK_NV_cuda_kernel_launch ===
|
|
|
1329 struct CudaModuleCreateInfoNV;
|
|
|
1330 struct CudaFunctionCreateInfoNV;
|
|
|
1331 struct CudaLaunchInfoNV;
|
|
|
1332 struct PhysicalDeviceCudaKernelLaunchFeaturesNV;
|
|
|
1333 struct PhysicalDeviceCudaKernelLaunchPropertiesNV;
|
|
|
1334 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
1335
|
|
|
1336 //=== VK_QCOM_tile_shading ===
|
|
|
1337 struct PhysicalDeviceTileShadingFeaturesQCOM;
|
|
|
1338 struct PhysicalDeviceTileShadingPropertiesQCOM;
|
|
|
1339 struct RenderPassTileShadingCreateInfoQCOM;
|
|
|
1340 struct PerTileBeginInfoQCOM;
|
|
|
1341 struct PerTileEndInfoQCOM;
|
|
|
1342 struct DispatchTileInfoQCOM;
|
|
|
1343
|
|
|
1344 //=== VK_NV_low_latency ===
|
|
|
1345 struct QueryLowLatencySupportNV;
|
|
|
1346
|
|
|
1347 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
1348 //=== VK_EXT_metal_objects ===
|
|
|
1349 struct ExportMetalObjectCreateInfoEXT;
|
|
|
1350 struct ExportMetalObjectsInfoEXT;
|
|
|
1351 struct ExportMetalDeviceInfoEXT;
|
|
|
1352 struct ExportMetalCommandQueueInfoEXT;
|
|
|
1353 struct ExportMetalBufferInfoEXT;
|
|
|
1354 struct ImportMetalBufferInfoEXT;
|
|
|
1355 struct ExportMetalTextureInfoEXT;
|
|
|
1356 struct ImportMetalTextureInfoEXT;
|
|
|
1357 struct ExportMetalIOSurfaceInfoEXT;
|
|
|
1358 struct ImportMetalIOSurfaceInfoEXT;
|
|
|
1359 struct ExportMetalSharedEventInfoEXT;
|
|
|
1360 struct ImportMetalSharedEventInfoEXT;
|
|
|
1361 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
1362
|
|
|
1363 //=== VK_EXT_descriptor_buffer ===
|
|
|
1364 struct PhysicalDeviceDescriptorBufferPropertiesEXT;
|
|
|
1365 struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
|
|
|
1366 struct PhysicalDeviceDescriptorBufferFeaturesEXT;
|
|
|
1367 struct DescriptorAddressInfoEXT;
|
|
|
1368 struct DescriptorBufferBindingInfoEXT;
|
|
|
1369 struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;
|
|
|
1370 union DescriptorDataEXT;
|
|
|
1371 struct DescriptorGetInfoEXT;
|
|
|
1372 struct BufferCaptureDescriptorDataInfoEXT;
|
|
|
1373 struct ImageCaptureDescriptorDataInfoEXT;
|
|
|
1374 struct ImageViewCaptureDescriptorDataInfoEXT;
|
|
|
1375 struct SamplerCaptureDescriptorDataInfoEXT;
|
|
|
1376 struct OpaqueCaptureDescriptorDataCreateInfoEXT;
|
|
|
1377 struct AccelerationStructureCaptureDescriptorDataInfoEXT;
|
|
|
1378
|
|
|
1379 //=== VK_EXT_graphics_pipeline_library ===
|
|
|
1380 struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
|
|
|
1381 struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
|
|
|
1382 struct GraphicsPipelineLibraryCreateInfoEXT;
|
|
|
1383
|
|
|
1384 //=== VK_AMD_shader_early_and_late_fragment_tests ===
|
|
|
1385 struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
|
|
|
1386
|
|
|
1387 //=== VK_KHR_fragment_shader_barycentric ===
|
|
|
1388 struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
|
|
|
1389 using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
|
|
|
1390 struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
|
|
|
1391
|
|
|
1392 //=== VK_KHR_shader_subgroup_uniform_control_flow ===
|
|
|
1393 struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
|
|
|
1394
|
|
|
1395 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
1396 struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
|
|
|
1397 struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
|
|
|
1398 struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
|
|
|
1399
|
|
|
1400 //=== VK_NV_ray_tracing_motion_blur ===
|
|
|
1401 struct AccelerationStructureGeometryMotionTrianglesDataNV;
|
|
|
1402 struct AccelerationStructureMotionInfoNV;
|
|
|
1403 struct AccelerationStructureMotionInstanceNV;
|
|
|
1404 union AccelerationStructureMotionInstanceDataNV;
|
|
|
1405 struct AccelerationStructureMatrixMotionInstanceNV;
|
|
|
1406 struct AccelerationStructureSRTMotionInstanceNV;
|
|
|
1407 struct SRTDataNV;
|
|
|
1408 struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
|
|
|
1409
|
|
|
1410 //=== VK_EXT_mesh_shader ===
|
|
|
1411 struct PhysicalDeviceMeshShaderFeaturesEXT;
|
|
|
1412 struct PhysicalDeviceMeshShaderPropertiesEXT;
|
|
|
1413 struct DrawMeshTasksIndirectCommandEXT;
|
|
|
1414
|
|
|
1415 //=== VK_EXT_ycbcr_2plane_444_formats ===
|
|
|
1416 struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
|
|
|
1417
|
|
|
1418 //=== VK_EXT_fragment_density_map2 ===
|
|
|
1419 struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
|
|
|
1420 struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
|
|
|
1421
|
|
|
1422 //=== VK_QCOM_rotated_copy_commands ===
|
|
|
1423 struct CopyCommandTransformInfoQCOM;
|
|
|
1424
|
|
|
1425 //=== VK_KHR_workgroup_memory_explicit_layout ===
|
|
|
1426 struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
|
|
|
1427
|
|
|
1428 //=== VK_EXT_image_compression_control ===
|
|
|
1429 struct PhysicalDeviceImageCompressionControlFeaturesEXT;
|
|
|
1430 struct ImageCompressionControlEXT;
|
|
|
1431 struct ImageCompressionPropertiesEXT;
|
|
|
1432
|
|
|
1433 //=== VK_EXT_attachment_feedback_loop_layout ===
|
|
|
1434 struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
|
|
|
1435
|
|
|
1436 //=== VK_EXT_4444_formats ===
|
|
|
1437 struct PhysicalDevice4444FormatsFeaturesEXT;
|
|
|
1438
|
|
|
1439 //=== VK_EXT_device_fault ===
|
|
|
1440 struct PhysicalDeviceFaultFeaturesEXT;
|
|
|
1441 struct DeviceFaultCountsEXT;
|
|
|
1442 struct DeviceFaultInfoEXT;
|
|
|
1443 struct DeviceFaultAddressInfoEXT;
|
|
|
1444 struct DeviceFaultVendorInfoEXT;
|
|
|
1445 struct DeviceFaultVendorBinaryHeaderVersionOneEXT;
|
|
|
1446
|
|
|
1447 //=== VK_EXT_rgba10x6_formats ===
|
|
|
1448 struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
|
|
|
1449
|
|
|
1450 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
1451 //=== VK_EXT_directfb_surface ===
|
|
|
1452 struct DirectFBSurfaceCreateInfoEXT;
|
|
|
1453 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
1454
|
|
|
1455 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
1456 struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
|
|
|
1457 struct VertexInputBindingDescription2EXT;
|
|
|
1458 struct VertexInputAttributeDescription2EXT;
|
|
|
1459
|
|
|
1460 //=== VK_EXT_physical_device_drm ===
|
|
|
1461 struct PhysicalDeviceDrmPropertiesEXT;
|
|
|
1462
|
|
|
1463 //=== VK_EXT_device_address_binding_report ===
|
|
|
1464 struct PhysicalDeviceAddressBindingReportFeaturesEXT;
|
|
|
1465 struct DeviceAddressBindingCallbackDataEXT;
|
|
|
1466
|
|
|
1467 //=== VK_EXT_depth_clip_control ===
|
|
|
1468 struct PhysicalDeviceDepthClipControlFeaturesEXT;
|
|
|
1469 struct PipelineViewportDepthClipControlCreateInfoEXT;
|
|
|
1470
|
|
|
1471 //=== VK_EXT_primitive_topology_list_restart ===
|
|
|
1472 struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
|
|
|
1473
|
|
|
1474 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
1475 //=== VK_FUCHSIA_external_memory ===
|
|
|
1476 struct ImportMemoryZirconHandleInfoFUCHSIA;
|
|
|
1477 struct MemoryZirconHandlePropertiesFUCHSIA;
|
|
|
1478 struct MemoryGetZirconHandleInfoFUCHSIA;
|
|
|
1479 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
1480
|
|
|
1481 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
1482 //=== VK_FUCHSIA_external_semaphore ===
|
|
|
1483 struct ImportSemaphoreZirconHandleInfoFUCHSIA;
|
|
|
1484 struct SemaphoreGetZirconHandleInfoFUCHSIA;
|
|
|
1485 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
1486
|
|
|
1487 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
1488 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
1489 struct BufferCollectionCreateInfoFUCHSIA;
|
|
|
1490 struct ImportMemoryBufferCollectionFUCHSIA;
|
|
|
1491 struct BufferCollectionImageCreateInfoFUCHSIA;
|
|
|
1492 struct BufferConstraintsInfoFUCHSIA;
|
|
|
1493 struct BufferCollectionBufferCreateInfoFUCHSIA;
|
|
|
1494 struct BufferCollectionPropertiesFUCHSIA;
|
|
|
1495 struct SysmemColorSpaceFUCHSIA;
|
|
|
1496 struct ImageConstraintsInfoFUCHSIA;
|
|
|
1497 struct ImageFormatConstraintsInfoFUCHSIA;
|
|
|
1498 struct BufferCollectionConstraintsInfoFUCHSIA;
|
|
|
1499 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
1500
|
|
|
1501 //=== VK_HUAWEI_subpass_shading ===
|
|
|
1502 struct SubpassShadingPipelineCreateInfoHUAWEI;
|
|
|
1503 struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
|
|
|
1504 struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
|
|
|
1505
|
|
|
1506 //=== VK_HUAWEI_invocation_mask ===
|
|
|
1507 struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
|
|
|
1508
|
|
|
1509 //=== VK_NV_external_memory_rdma ===
|
|
|
1510 struct MemoryGetRemoteAddressInfoNV;
|
|
|
1511 struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
|
|
|
1512
|
|
|
1513 //=== VK_EXT_pipeline_properties ===
|
|
|
1514 struct PipelinePropertiesIdentifierEXT;
|
|
|
1515 struct PhysicalDevicePipelinePropertiesFeaturesEXT;
|
|
|
1516
|
|
|
1517 //=== VK_EXT_frame_boundary ===
|
|
|
1518 struct PhysicalDeviceFrameBoundaryFeaturesEXT;
|
|
|
1519 struct FrameBoundaryEXT;
|
|
|
1520
|
|
|
1521 //=== VK_EXT_multisampled_render_to_single_sampled ===
|
|
|
1522 struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
|
|
|
1523 struct SubpassResolvePerformanceQueryEXT;
|
|
|
1524 struct MultisampledRenderToSingleSampledInfoEXT;
|
|
|
1525
|
|
|
1526 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
1527 struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
|
|
|
1528
|
|
|
1529 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
1530 //=== VK_QNX_screen_surface ===
|
|
|
1531 struct ScreenSurfaceCreateInfoQNX;
|
|
|
1532 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
1533
|
|
|
1534 //=== VK_EXT_color_write_enable ===
|
|
|
1535 struct PhysicalDeviceColorWriteEnableFeaturesEXT;
|
|
|
1536 struct PipelineColorWriteCreateInfoEXT;
|
|
|
1537
|
|
|
1538 //=== VK_EXT_primitives_generated_query ===
|
|
|
1539 struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
|
|
|
1540
|
|
|
1541 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
1542 struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
|
|
|
1543 struct TraceRaysIndirectCommand2KHR;
|
|
|
1544
|
|
|
1545 //=== VK_KHR_shader_untyped_pointers ===
|
|
|
1546 struct PhysicalDeviceShaderUntypedPointersFeaturesKHR;
|
|
|
1547
|
|
|
1548 //=== VK_VALVE_video_encode_rgb_conversion ===
|
|
|
1549 struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
|
|
|
1550 struct VideoEncodeRgbConversionCapabilitiesVALVE;
|
|
|
1551 struct VideoEncodeProfileRgbConversionInfoVALVE;
|
|
|
1552 struct VideoEncodeSessionRgbConversionCreateInfoVALVE;
|
|
|
1553
|
|
|
1554 //=== VK_EXT_image_view_min_lod ===
|
|
|
1555 struct PhysicalDeviceImageViewMinLodFeaturesEXT;
|
|
|
1556 struct ImageViewMinLodCreateInfoEXT;
|
|
|
1557
|
|
|
1558 //=== VK_EXT_multi_draw ===
|
|
|
1559 struct PhysicalDeviceMultiDrawFeaturesEXT;
|
|
|
1560 struct PhysicalDeviceMultiDrawPropertiesEXT;
|
|
|
1561 struct MultiDrawInfoEXT;
|
|
|
1562 struct MultiDrawIndexedInfoEXT;
|
|
|
1563
|
|
|
1564 //=== VK_EXT_image_2d_view_of_3d ===
|
|
|
1565 struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;
|
|
|
1566
|
|
|
1567 //=== VK_EXT_shader_tile_image ===
|
|
|
1568 struct PhysicalDeviceShaderTileImageFeaturesEXT;
|
|
|
1569 struct PhysicalDeviceShaderTileImagePropertiesEXT;
|
|
|
1570
|
|
|
1571 //=== VK_EXT_opacity_micromap ===
|
|
|
1572 struct MicromapBuildInfoEXT;
|
|
|
1573 struct MicromapUsageEXT;
|
|
|
1574 struct MicromapCreateInfoEXT;
|
|
|
1575 struct PhysicalDeviceOpacityMicromapFeaturesEXT;
|
|
|
1576 struct PhysicalDeviceOpacityMicromapPropertiesEXT;
|
|
|
1577 struct MicromapVersionInfoEXT;
|
|
|
1578 struct CopyMicromapToMemoryInfoEXT;
|
|
|
1579 struct CopyMemoryToMicromapInfoEXT;
|
|
|
1580 struct CopyMicromapInfoEXT;
|
|
|
1581 struct MicromapBuildSizesInfoEXT;
|
|
|
1582 struct AccelerationStructureTrianglesOpacityMicromapEXT;
|
|
|
1583 struct MicromapTriangleEXT;
|
|
|
1584
|
|
|
1585 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
1586 //=== VK_NV_displacement_micromap ===
|
|
|
1587 struct PhysicalDeviceDisplacementMicromapFeaturesNV;
|
|
|
1588 struct PhysicalDeviceDisplacementMicromapPropertiesNV;
|
|
|
1589 struct AccelerationStructureTrianglesDisplacementMicromapNV;
|
|
|
1590 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
1591
|
|
|
1592 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
1593 struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
|
|
|
1594 struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
|
|
|
1595 struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI;
|
|
|
1596
|
|
|
1597 //=== VK_EXT_border_color_swizzle ===
|
|
|
1598 struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
|
|
|
1599 struct SamplerBorderColorComponentMappingCreateInfoEXT;
|
|
|
1600
|
|
|
1601 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
1602 struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
|
|
|
1603
|
|
|
1604 //=== VK_ARM_shader_core_properties ===
|
|
|
1605 struct PhysicalDeviceShaderCorePropertiesARM;
|
|
|
1606
|
|
|
1607 //=== VK_ARM_scheduling_controls ===
|
|
|
1608 struct DeviceQueueShaderCoreControlCreateInfoARM;
|
|
|
1609 struct PhysicalDeviceSchedulingControlsFeaturesARM;
|
|
|
1610 struct PhysicalDeviceSchedulingControlsPropertiesARM;
|
|
|
1611
|
|
|
1612 //=== VK_EXT_image_sliced_view_of_3d ===
|
|
|
1613 struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
|
|
|
1614 struct ImageViewSlicedCreateInfoEXT;
|
|
|
1615
|
|
|
1616 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
1617 struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
|
|
|
1618 struct DescriptorSetBindingReferenceVALVE;
|
|
|
1619 struct DescriptorSetLayoutHostMappingInfoVALVE;
|
|
|
1620
|
|
|
1621 //=== VK_EXT_non_seamless_cube_map ===
|
|
|
1622 struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
|
|
|
1623
|
|
|
1624 //=== VK_ARM_render_pass_striped ===
|
|
|
1625 struct PhysicalDeviceRenderPassStripedFeaturesARM;
|
|
|
1626 struct PhysicalDeviceRenderPassStripedPropertiesARM;
|
|
|
1627 struct RenderPassStripeBeginInfoARM;
|
|
|
1628 struct RenderPassStripeInfoARM;
|
|
|
1629 struct RenderPassStripeSubmitInfoARM;
|
|
|
1630
|
|
|
1631 //=== VK_NV_copy_memory_indirect ===
|
|
|
1632 struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
|
|
|
1633
|
|
|
1634 //=== VK_NV_memory_decompression ===
|
|
|
1635 struct DecompressMemoryRegionNV;
|
|
|
1636
|
|
|
1637 //=== VK_NV_device_generated_commands_compute ===
|
|
|
1638 struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
|
|
|
1639 struct ComputePipelineIndirectBufferInfoNV;
|
|
|
1640 struct PipelineIndirectDeviceAddressInfoNV;
|
|
|
1641 struct BindPipelineIndirectCommandNV;
|
|
|
1642
|
|
|
1643 //=== VK_NV_ray_tracing_linear_swept_spheres ===
|
|
|
1644 struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
|
|
|
1645 struct AccelerationStructureGeometryLinearSweptSpheresDataNV;
|
|
|
1646 struct AccelerationStructureGeometrySpheresDataNV;
|
|
|
1647
|
|
|
1648 //=== VK_NV_linear_color_attachment ===
|
|
|
1649 struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
|
|
|
1650
|
|
|
1651 //=== VK_KHR_shader_maximal_reconvergence ===
|
|
|
1652 struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
|
|
|
1653
|
|
|
1654 //=== VK_EXT_image_compression_control_swapchain ===
|
|
|
1655 struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
|
|
|
1656
|
|
|
1657 //=== VK_QCOM_image_processing ===
|
|
|
1658 struct ImageViewSampleWeightCreateInfoQCOM;
|
|
|
1659 struct PhysicalDeviceImageProcessingFeaturesQCOM;
|
|
|
1660 struct PhysicalDeviceImageProcessingPropertiesQCOM;
|
|
|
1661
|
|
|
1662 //=== VK_EXT_nested_command_buffer ===
|
|
|
1663 struct PhysicalDeviceNestedCommandBufferFeaturesEXT;
|
|
|
1664 struct PhysicalDeviceNestedCommandBufferPropertiesEXT;
|
|
|
1665
|
|
|
1666 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
1667 //=== VK_OHOS_external_memory ===
|
|
|
1668 struct NativeBufferUsageOHOS;
|
|
|
1669 struct NativeBufferPropertiesOHOS;
|
|
|
1670 struct NativeBufferFormatPropertiesOHOS;
|
|
|
1671 struct ImportNativeBufferInfoOHOS;
|
|
|
1672 struct MemoryGetNativeBufferInfoOHOS;
|
|
|
1673 struct ExternalFormatOHOS;
|
|
|
1674 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
1675
|
|
|
1676 //=== VK_EXT_external_memory_acquire_unmodified ===
|
|
|
1677 struct ExternalMemoryAcquireUnmodifiedEXT;
|
|
|
1678
|
|
|
1679 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
1680 struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
|
|
|
1681 struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;
|
|
|
1682 struct ColorBlendEquationEXT;
|
|
|
1683 struct ColorBlendAdvancedEXT;
|
|
|
1684
|
|
|
1685 //=== VK_EXT_subpass_merge_feedback ===
|
|
|
1686 struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
|
|
|
1687 struct RenderPassCreationControlEXT;
|
|
|
1688 struct RenderPassCreationFeedbackInfoEXT;
|
|
|
1689 struct RenderPassCreationFeedbackCreateInfoEXT;
|
|
|
1690 struct RenderPassSubpassFeedbackInfoEXT;
|
|
|
1691 struct RenderPassSubpassFeedbackCreateInfoEXT;
|
|
|
1692
|
|
|
1693 //=== VK_LUNARG_direct_driver_loading ===
|
|
|
1694 struct DirectDriverLoadingInfoLUNARG;
|
|
|
1695 struct DirectDriverLoadingListLUNARG;
|
|
|
1696
|
|
|
1697 //=== VK_ARM_tensors ===
|
|
|
1698 struct TensorDescriptionARM;
|
|
|
1699 struct TensorCreateInfoARM;
|
|
|
1700 struct TensorViewCreateInfoARM;
|
|
|
1701 struct TensorMemoryRequirementsInfoARM;
|
|
|
1702 struct BindTensorMemoryInfoARM;
|
|
|
1703 struct WriteDescriptorSetTensorARM;
|
|
|
1704 struct TensorFormatPropertiesARM;
|
|
|
1705 struct PhysicalDeviceTensorPropertiesARM;
|
|
|
1706 struct TensorMemoryBarrierARM;
|
|
|
1707 struct TensorDependencyInfoARM;
|
|
|
1708 struct PhysicalDeviceTensorFeaturesARM;
|
|
|
1709 struct DeviceTensorMemoryRequirementsARM;
|
|
|
1710 struct CopyTensorInfoARM;
|
|
|
1711 struct TensorCopyARM;
|
|
|
1712 struct MemoryDedicatedAllocateInfoTensorARM;
|
|
|
1713 struct PhysicalDeviceExternalTensorInfoARM;
|
|
|
1714 struct ExternalTensorPropertiesARM;
|
|
|
1715 struct ExternalMemoryTensorCreateInfoARM;
|
|
|
1716 struct PhysicalDeviceDescriptorBufferTensorFeaturesARM;
|
|
|
1717 struct PhysicalDeviceDescriptorBufferTensorPropertiesARM;
|
|
|
1718 struct DescriptorGetTensorInfoARM;
|
|
|
1719 struct TensorCaptureDescriptorDataInfoARM;
|
|
|
1720 struct TensorViewCaptureDescriptorDataInfoARM;
|
|
|
1721 struct FrameBoundaryTensorsARM;
|
|
|
1722
|
|
|
1723 //=== VK_EXT_shader_module_identifier ===
|
|
|
1724 struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
|
|
|
1725 struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
|
|
|
1726 struct PipelineShaderStageModuleIdentifierCreateInfoEXT;
|
|
|
1727 struct ShaderModuleIdentifierEXT;
|
|
|
1728
|
|
|
1729 //=== VK_EXT_rasterization_order_attachment_access ===
|
|
|
1730 struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
|
|
|
1731 using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
|
|
|
1732
|
|
|
1733 //=== VK_NV_optical_flow ===
|
|
|
1734 struct PhysicalDeviceOpticalFlowFeaturesNV;
|
|
|
1735 struct PhysicalDeviceOpticalFlowPropertiesNV;
|
|
|
1736 struct OpticalFlowImageFormatInfoNV;
|
|
|
1737 struct OpticalFlowImageFormatPropertiesNV;
|
|
|
1738 struct OpticalFlowSessionCreateInfoNV;
|
|
|
1739 struct OpticalFlowSessionCreatePrivateDataInfoNV;
|
|
|
1740 struct OpticalFlowExecuteInfoNV;
|
|
|
1741
|
|
|
1742 //=== VK_EXT_legacy_dithering ===
|
|
|
1743 struct PhysicalDeviceLegacyDitheringFeaturesEXT;
|
|
|
1744
|
|
|
1745 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
1746 //=== VK_ANDROID_external_format_resolve ===
|
|
|
1747 struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
|
|
|
1748 struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
|
|
|
1749 struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
|
|
|
1750 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
1751
|
|
|
1752 //=== VK_AMD_anti_lag ===
|
|
|
1753 struct PhysicalDeviceAntiLagFeaturesAMD;
|
|
|
1754 struct AntiLagDataAMD;
|
|
|
1755 struct AntiLagPresentationInfoAMD;
|
|
|
1756
|
|
|
1757 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
1758 //=== VK_AMDX_dense_geometry_format ===
|
|
|
1759 struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX;
|
|
|
1760 struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
|
|
|
1761 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
1762
|
|
|
1763 //=== VK_KHR_present_id2 ===
|
|
|
1764 struct SurfaceCapabilitiesPresentId2KHR;
|
|
|
1765 struct PresentId2KHR;
|
|
|
1766 struct PhysicalDevicePresentId2FeaturesKHR;
|
|
|
1767
|
|
|
1768 //=== VK_KHR_present_wait2 ===
|
|
|
1769 struct SurfaceCapabilitiesPresentWait2KHR;
|
|
|
1770 struct PhysicalDevicePresentWait2FeaturesKHR;
|
|
|
1771 struct PresentWait2InfoKHR;
|
|
|
1772
|
|
|
1773 //=== VK_KHR_ray_tracing_position_fetch ===
|
|
|
1774 struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
|
|
|
1775
|
|
|
1776 //=== VK_EXT_shader_object ===
|
|
|
1777 struct PhysicalDeviceShaderObjectFeaturesEXT;
|
|
|
1778 struct PhysicalDeviceShaderObjectPropertiesEXT;
|
|
|
1779 struct ShaderCreateInfoEXT;
|
|
|
1780
|
|
|
1781 //=== VK_KHR_pipeline_binary ===
|
|
|
1782 struct PhysicalDevicePipelineBinaryFeaturesKHR;
|
|
|
1783 struct PhysicalDevicePipelineBinaryPropertiesKHR;
|
|
|
1784 struct DevicePipelineBinaryInternalCacheControlKHR;
|
|
|
1785 struct PipelineBinaryKeyKHR;
|
|
|
1786 struct PipelineBinaryDataKHR;
|
|
|
1787 struct PipelineBinaryKeysAndDataKHR;
|
|
|
1788 struct PipelineBinaryCreateInfoKHR;
|
|
|
1789 struct PipelineBinaryInfoKHR;
|
|
|
1790 struct ReleaseCapturedPipelineDataInfoKHR;
|
|
|
1791 struct PipelineBinaryDataInfoKHR;
|
|
|
1792 struct PipelineCreateInfoKHR;
|
|
|
1793 struct PipelineBinaryHandlesInfoKHR;
|
|
|
1794
|
|
|
1795 //=== VK_QCOM_tile_properties ===
|
|
|
1796 struct PhysicalDeviceTilePropertiesFeaturesQCOM;
|
|
|
1797 struct TilePropertiesQCOM;
|
|
|
1798
|
|
|
1799 //=== VK_SEC_amigo_profiling ===
|
|
|
1800 struct PhysicalDeviceAmigoProfilingFeaturesSEC;
|
|
|
1801 struct AmigoProfilingSubmitInfoSEC;
|
|
|
1802
|
|
|
1803 //=== VK_KHR_surface_maintenance1 ===
|
|
|
1804 struct SurfacePresentModeKHR;
|
|
|
1805 using SurfacePresentModeEXT = SurfacePresentModeKHR;
|
|
|
1806 struct SurfacePresentScalingCapabilitiesKHR;
|
|
|
1807 using SurfacePresentScalingCapabilitiesEXT = SurfacePresentScalingCapabilitiesKHR;
|
|
|
1808 struct SurfacePresentModeCompatibilityKHR;
|
|
|
1809 using SurfacePresentModeCompatibilityEXT = SurfacePresentModeCompatibilityKHR;
|
|
|
1810
|
|
|
1811 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
1812 struct PhysicalDeviceSwapchainMaintenance1FeaturesKHR;
|
|
|
1813 using PhysicalDeviceSwapchainMaintenance1FeaturesEXT = PhysicalDeviceSwapchainMaintenance1FeaturesKHR;
|
|
|
1814 struct SwapchainPresentFenceInfoKHR;
|
|
|
1815 using SwapchainPresentFenceInfoEXT = SwapchainPresentFenceInfoKHR;
|
|
|
1816 struct SwapchainPresentModesCreateInfoKHR;
|
|
|
1817 using SwapchainPresentModesCreateInfoEXT = SwapchainPresentModesCreateInfoKHR;
|
|
|
1818 struct SwapchainPresentModeInfoKHR;
|
|
|
1819 using SwapchainPresentModeInfoEXT = SwapchainPresentModeInfoKHR;
|
|
|
1820 struct SwapchainPresentScalingCreateInfoKHR;
|
|
|
1821 using SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR;
|
|
|
1822 struct ReleaseSwapchainImagesInfoKHR;
|
|
|
1823 using ReleaseSwapchainImagesInfoEXT = ReleaseSwapchainImagesInfoKHR;
|
|
|
1824
|
|
|
1825 //=== VK_QCOM_multiview_per_view_viewports ===
|
|
|
1826 struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
|
|
|
1827
|
|
|
1828 //=== VK_NV_ray_tracing_invocation_reorder ===
|
|
|
1829 struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
|
|
|
1830 struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
|
|
|
1831
|
|
|
1832 //=== VK_NV_cooperative_vector ===
|
|
|
1833 struct PhysicalDeviceCooperativeVectorPropertiesNV;
|
|
|
1834 struct PhysicalDeviceCooperativeVectorFeaturesNV;
|
|
|
1835 struct CooperativeVectorPropertiesNV;
|
|
|
1836 struct ConvertCooperativeVectorMatrixInfoNV;
|
|
|
1837
|
|
|
1838 //=== VK_NV_extended_sparse_address_space ===
|
|
|
1839 struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
|
|
|
1840 struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
|
|
|
1841
|
|
|
1842 //=== VK_EXT_mutable_descriptor_type ===
|
|
|
1843 struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
|
|
|
1844 using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
|
|
|
1845 struct MutableDescriptorTypeListEXT;
|
|
|
1846 using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
|
|
|
1847 struct MutableDescriptorTypeCreateInfoEXT;
|
|
|
1848 using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
|
|
|
1849
|
|
|
1850 //=== VK_EXT_legacy_vertex_attributes ===
|
|
|
1851 struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT;
|
|
|
1852 struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT;
|
|
|
1853
|
|
|
1854 //=== VK_EXT_layer_settings ===
|
|
|
1855 struct LayerSettingsCreateInfoEXT;
|
|
|
1856 struct LayerSettingEXT;
|
|
|
1857
|
|
|
1858 //=== VK_ARM_shader_core_builtins ===
|
|
|
1859 struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
|
|
|
1860 struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
|
|
|
1861
|
|
|
1862 //=== VK_EXT_pipeline_library_group_handles ===
|
|
|
1863 struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
|
|
|
1864
|
|
|
1865 //=== VK_EXT_dynamic_rendering_unused_attachments ===
|
|
|
1866 struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
|
|
|
1867
|
|
|
1868 //=== VK_NV_low_latency2 ===
|
|
|
1869 struct LatencySleepModeInfoNV;
|
|
|
1870 struct LatencySleepInfoNV;
|
|
|
1871 struct SetLatencyMarkerInfoNV;
|
|
|
1872 struct GetLatencyMarkerInfoNV;
|
|
|
1873 struct LatencyTimingsFrameReportNV;
|
|
|
1874 struct LatencySubmissionPresentIdNV;
|
|
|
1875 struct SwapchainLatencyCreateInfoNV;
|
|
|
1876 struct OutOfBandQueueTypeInfoNV;
|
|
|
1877 struct LatencySurfaceCapabilitiesNV;
|
|
|
1878
|
|
|
1879 //=== VK_KHR_cooperative_matrix ===
|
|
|
1880 struct CooperativeMatrixPropertiesKHR;
|
|
|
1881 struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
|
|
|
1882 struct PhysicalDeviceCooperativeMatrixPropertiesKHR;
|
|
|
1883
|
|
|
1884 //=== VK_ARM_data_graph ===
|
|
|
1885 struct PhysicalDeviceDataGraphFeaturesARM;
|
|
|
1886 struct DataGraphPipelineConstantARM;
|
|
|
1887 struct DataGraphPipelineResourceInfoARM;
|
|
|
1888 struct DataGraphPipelineCompilerControlCreateInfoARM;
|
|
|
1889 struct DataGraphPipelineCreateInfoARM;
|
|
|
1890 struct DataGraphPipelineShaderModuleCreateInfoARM;
|
|
|
1891 struct DataGraphPipelineSessionCreateInfoARM;
|
|
|
1892 struct DataGraphPipelineSessionBindPointRequirementsInfoARM;
|
|
|
1893 struct DataGraphPipelineSessionBindPointRequirementARM;
|
|
|
1894 struct DataGraphPipelineSessionMemoryRequirementsInfoARM;
|
|
|
1895 struct BindDataGraphPipelineSessionMemoryInfoARM;
|
|
|
1896 struct DataGraphPipelineInfoARM;
|
|
|
1897 struct DataGraphPipelinePropertyQueryResultARM;
|
|
|
1898 struct DataGraphPipelineIdentifierCreateInfoARM;
|
|
|
1899 struct DataGraphPipelineDispatchInfoARM;
|
|
|
1900 struct PhysicalDeviceDataGraphProcessingEngineARM;
|
|
|
1901 struct QueueFamilyDataGraphPropertiesARM;
|
|
|
1902 struct DataGraphProcessingEngineCreateInfoARM;
|
|
|
1903 struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM;
|
|
|
1904 struct QueueFamilyDataGraphProcessingEnginePropertiesARM;
|
|
|
1905 struct PhysicalDeviceDataGraphOperationSupportARM;
|
|
|
1906 struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;
|
|
|
1907
|
|
|
1908 //=== VK_QCOM_multiview_per_view_render_areas ===
|
|
|
1909 struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
|
|
|
1910 struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
|
|
|
1911
|
|
|
1912 //=== VK_KHR_compute_shader_derivatives ===
|
|
|
1913 struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR;
|
|
|
1914 using PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR;
|
|
|
1915 struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR;
|
|
|
1916
|
|
|
1917 //=== VK_KHR_video_decode_av1 ===
|
|
|
1918 struct VideoDecodeAV1ProfileInfoKHR;
|
|
|
1919 struct VideoDecodeAV1CapabilitiesKHR;
|
|
|
1920 struct VideoDecodeAV1SessionParametersCreateInfoKHR;
|
|
|
1921 struct VideoDecodeAV1PictureInfoKHR;
|
|
|
1922 struct VideoDecodeAV1DpbSlotInfoKHR;
|
|
|
1923
|
|
|
1924 //=== VK_KHR_video_encode_av1 ===
|
|
|
1925 struct PhysicalDeviceVideoEncodeAV1FeaturesKHR;
|
|
|
1926 struct VideoEncodeAV1CapabilitiesKHR;
|
|
|
1927 struct VideoEncodeAV1QualityLevelPropertiesKHR;
|
|
|
1928 struct VideoEncodeAV1SessionCreateInfoKHR;
|
|
|
1929 struct VideoEncodeAV1SessionParametersCreateInfoKHR;
|
|
|
1930 struct VideoEncodeAV1PictureInfoKHR;
|
|
|
1931 struct VideoEncodeAV1DpbSlotInfoKHR;
|
|
|
1932 struct VideoEncodeAV1ProfileInfoKHR;
|
|
|
1933 struct VideoEncodeAV1QIndexKHR;
|
|
|
1934 struct VideoEncodeAV1FrameSizeKHR;
|
|
|
1935 struct VideoEncodeAV1GopRemainingFrameInfoKHR;
|
|
|
1936 struct VideoEncodeAV1RateControlInfoKHR;
|
|
|
1937 struct VideoEncodeAV1RateControlLayerInfoKHR;
|
|
|
1938
|
|
|
1939 //=== VK_KHR_video_decode_vp9 ===
|
|
|
1940 struct PhysicalDeviceVideoDecodeVP9FeaturesKHR;
|
|
|
1941 struct VideoDecodeVP9ProfileInfoKHR;
|
|
|
1942 struct VideoDecodeVP9CapabilitiesKHR;
|
|
|
1943 struct VideoDecodeVP9PictureInfoKHR;
|
|
|
1944
|
|
|
1945 //=== VK_KHR_video_maintenance1 ===
|
|
|
1946 struct PhysicalDeviceVideoMaintenance1FeaturesKHR;
|
|
|
1947 struct VideoInlineQueryInfoKHR;
|
|
|
1948
|
|
|
1949 //=== VK_NV_per_stage_descriptor_set ===
|
|
|
1950 struct PhysicalDevicePerStageDescriptorSetFeaturesNV;
|
|
|
1951
|
|
|
1952 //=== VK_QCOM_image_processing2 ===
|
|
|
1953 struct PhysicalDeviceImageProcessing2FeaturesQCOM;
|
|
|
1954 struct PhysicalDeviceImageProcessing2PropertiesQCOM;
|
|
|
1955 struct SamplerBlockMatchWindowCreateInfoQCOM;
|
|
|
1956
|
|
|
1957 //=== VK_QCOM_filter_cubic_weights ===
|
|
|
1958 struct PhysicalDeviceCubicWeightsFeaturesQCOM;
|
|
|
1959 struct SamplerCubicWeightsCreateInfoQCOM;
|
|
|
1960 struct BlitImageCubicWeightsInfoQCOM;
|
|
|
1961
|
|
|
1962 //=== VK_QCOM_ycbcr_degamma ===
|
|
|
1963 struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;
|
|
|
1964 struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
|
|
|
1965
|
|
|
1966 //=== VK_QCOM_filter_cubic_clamp ===
|
|
|
1967 struct PhysicalDeviceCubicClampFeaturesQCOM;
|
|
|
1968
|
|
|
1969 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
1970 struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
|
|
|
1971
|
|
|
1972 //=== VK_KHR_unified_image_layouts ===
|
|
|
1973 struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR;
|
|
|
1974 struct AttachmentFeedbackLoopInfoEXT;
|
|
|
1975
|
|
|
1976 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
1977 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
1978 struct ScreenBufferPropertiesQNX;
|
|
|
1979 struct ScreenBufferFormatPropertiesQNX;
|
|
|
1980 struct ImportScreenBufferInfoQNX;
|
|
|
1981 struct ExternalFormatQNX;
|
|
|
1982 struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
|
|
|
1983 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
1984
|
|
|
1985 //=== VK_MSFT_layered_driver ===
|
|
|
1986 struct PhysicalDeviceLayeredDriverPropertiesMSFT;
|
|
|
1987
|
|
|
1988 //=== VK_KHR_calibrated_timestamps ===
|
|
|
1989 struct CalibratedTimestampInfoKHR;
|
|
|
1990 using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
|
|
|
1991
|
|
|
1992 //=== VK_KHR_maintenance6 ===
|
|
|
1993 struct SetDescriptorBufferOffsetsInfoEXT;
|
|
|
1994 struct BindDescriptorBufferEmbeddedSamplersInfoEXT;
|
|
|
1995
|
|
|
1996 //=== VK_NV_descriptor_pool_overallocation ===
|
|
|
1997 struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
|
|
|
1998
|
|
|
1999 //=== VK_QCOM_tile_memory_heap ===
|
|
|
2000 struct PhysicalDeviceTileMemoryHeapFeaturesQCOM;
|
|
|
2001 struct PhysicalDeviceTileMemoryHeapPropertiesQCOM;
|
|
|
2002 struct TileMemoryRequirementsQCOM;
|
|
|
2003 struct TileMemoryBindInfoQCOM;
|
|
|
2004 struct TileMemorySizeInfoQCOM;
|
|
|
2005
|
|
|
2006 //=== VK_KHR_copy_memory_indirect ===
|
|
|
2007 struct StridedDeviceAddressRangeKHR;
|
|
|
2008 struct CopyMemoryIndirectCommandKHR;
|
|
|
2009 using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR;
|
|
|
2010 struct CopyMemoryIndirectInfoKHR;
|
|
|
2011 struct CopyMemoryToImageIndirectCommandKHR;
|
|
|
2012 using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR;
|
|
|
2013 struct CopyMemoryToImageIndirectInfoKHR;
|
|
|
2014 struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR;
|
|
|
2015 struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
|
|
|
2016 using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
|
|
|
2017
|
|
|
2018 //=== VK_EXT_memory_decompression ===
|
|
|
2019 struct DecompressMemoryInfoEXT;
|
|
|
2020 struct DecompressMemoryRegionEXT;
|
|
|
2021 struct PhysicalDeviceMemoryDecompressionFeaturesEXT;
|
|
|
2022 using PhysicalDeviceMemoryDecompressionFeaturesNV = PhysicalDeviceMemoryDecompressionFeaturesEXT;
|
|
|
2023 struct PhysicalDeviceMemoryDecompressionPropertiesEXT;
|
|
|
2024 using PhysicalDeviceMemoryDecompressionPropertiesNV = PhysicalDeviceMemoryDecompressionPropertiesEXT;
|
|
|
2025
|
|
|
2026 //=== VK_NV_display_stereo ===
|
|
|
2027 struct DisplaySurfaceStereoCreateInfoNV;
|
|
|
2028 struct DisplayModeStereoPropertiesNV;
|
|
|
2029
|
|
|
2030 //=== VK_KHR_video_encode_intra_refresh ===
|
|
|
2031 struct VideoEncodeIntraRefreshCapabilitiesKHR;
|
|
|
2032 struct VideoEncodeSessionIntraRefreshCreateInfoKHR;
|
|
|
2033 struct VideoEncodeIntraRefreshInfoKHR;
|
|
|
2034 struct VideoReferenceIntraRefreshInfoKHR;
|
|
|
2035 struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR;
|
|
|
2036
|
|
|
2037 //=== VK_KHR_video_encode_quantization_map ===
|
|
|
2038 struct VideoEncodeQuantizationMapCapabilitiesKHR;
|
|
|
2039 struct VideoFormatQuantizationMapPropertiesKHR;
|
|
|
2040 struct VideoEncodeQuantizationMapInfoKHR;
|
|
|
2041 struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR;
|
|
|
2042 struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;
|
|
|
2043 struct VideoEncodeH264QuantizationMapCapabilitiesKHR;
|
|
|
2044 struct VideoEncodeH265QuantizationMapCapabilitiesKHR;
|
|
|
2045 struct VideoFormatH265QuantizationMapPropertiesKHR;
|
|
|
2046 struct VideoEncodeAV1QuantizationMapCapabilitiesKHR;
|
|
|
2047 struct VideoFormatAV1QuantizationMapPropertiesKHR;
|
|
|
2048
|
|
|
2049 //=== VK_NV_raw_access_chains ===
|
|
|
2050 struct PhysicalDeviceRawAccessChainsFeaturesNV;
|
|
|
2051
|
|
|
2052 //=== VK_NV_external_compute_queue ===
|
|
|
2053 struct ExternalComputeQueueDeviceCreateInfoNV;
|
|
|
2054 struct ExternalComputeQueueCreateInfoNV;
|
|
|
2055 struct ExternalComputeQueueDataParamsNV;
|
|
|
2056 struct PhysicalDeviceExternalComputeQueuePropertiesNV;
|
|
|
2057
|
|
|
2058 //=== VK_KHR_shader_relaxed_extended_instruction ===
|
|
|
2059 struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
|
|
|
2060
|
|
|
2061 //=== VK_NV_command_buffer_inheritance ===
|
|
|
2062 struct PhysicalDeviceCommandBufferInheritanceFeaturesNV;
|
|
|
2063
|
|
|
2064 //=== VK_KHR_maintenance7 ===
|
|
|
2065 struct PhysicalDeviceMaintenance7FeaturesKHR;
|
|
|
2066 struct PhysicalDeviceMaintenance7PropertiesKHR;
|
|
|
2067 struct PhysicalDeviceLayeredApiPropertiesListKHR;
|
|
|
2068 struct PhysicalDeviceLayeredApiPropertiesKHR;
|
|
|
2069 struct PhysicalDeviceLayeredApiVulkanPropertiesKHR;
|
|
|
2070
|
|
|
2071 //=== VK_NV_shader_atomic_float16_vector ===
|
|
|
2072 struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
|
|
|
2073
|
|
|
2074 //=== VK_EXT_shader_replicated_composites ===
|
|
|
2075 struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
|
|
|
2076
|
|
|
2077 //=== VK_EXT_shader_float8 ===
|
|
|
2078 struct PhysicalDeviceShaderFloat8FeaturesEXT;
|
|
|
2079
|
|
|
2080 //=== VK_NV_ray_tracing_validation ===
|
|
|
2081 struct PhysicalDeviceRayTracingValidationFeaturesNV;
|
|
|
2082
|
|
|
2083 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
2084 struct PhysicalDeviceClusterAccelerationStructureFeaturesNV;
|
|
|
2085 struct PhysicalDeviceClusterAccelerationStructurePropertiesNV;
|
|
|
2086 struct ClusterAccelerationStructureClustersBottomLevelInputNV;
|
|
|
2087 struct ClusterAccelerationStructureTriangleClusterInputNV;
|
|
|
2088 struct ClusterAccelerationStructureMoveObjectsInputNV;
|
|
|
2089 union ClusterAccelerationStructureOpInputNV;
|
|
|
2090 struct ClusterAccelerationStructureInputInfoNV;
|
|
|
2091 struct ClusterAccelerationStructureCommandsInfoNV;
|
|
|
2092 struct StridedDeviceAddressNV;
|
|
|
2093 struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
|
|
|
2094 struct ClusterAccelerationStructureMoveObjectsInfoNV;
|
|
|
2095 struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV;
|
|
|
2096 struct ClusterAccelerationStructureBuildTriangleClusterInfoNV;
|
|
|
2097 struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;
|
|
|
2098 struct ClusterAccelerationStructureInstantiateClusterInfoNV;
|
|
|
2099 struct ClusterAccelerationStructureGetTemplateIndicesInfoNV;
|
|
|
2100 struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV;
|
|
|
2101
|
|
|
2102 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
2103 struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV;
|
|
|
2104 struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV;
|
|
|
2105 struct PartitionedAccelerationStructureFlagsNV;
|
|
|
2106 struct BuildPartitionedAccelerationStructureIndirectCommandNV;
|
|
|
2107 struct PartitionedAccelerationStructureWriteInstanceDataNV;
|
|
|
2108 struct PartitionedAccelerationStructureUpdateInstanceDataNV;
|
|
|
2109 struct PartitionedAccelerationStructureWritePartitionTranslationDataNV;
|
|
|
2110 struct WriteDescriptorSetPartitionedAccelerationStructureNV;
|
|
|
2111 struct PartitionedAccelerationStructureInstancesInputNV;
|
|
|
2112 struct BuildPartitionedAccelerationStructureInfoNV;
|
|
|
2113
|
|
|
2114 //=== VK_EXT_device_generated_commands ===
|
|
|
2115 struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT;
|
|
|
2116 struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT;
|
|
|
2117 struct GeneratedCommandsMemoryRequirementsInfoEXT;
|
|
|
2118 struct IndirectExecutionSetCreateInfoEXT;
|
|
|
2119 union IndirectExecutionSetInfoEXT;
|
|
|
2120 struct IndirectExecutionSetPipelineInfoEXT;
|
|
|
2121 struct IndirectExecutionSetShaderInfoEXT;
|
|
|
2122 struct GeneratedCommandsInfoEXT;
|
|
|
2123 struct WriteIndirectExecutionSetPipelineEXT;
|
|
|
2124 struct IndirectCommandsLayoutCreateInfoEXT;
|
|
|
2125 struct IndirectCommandsLayoutTokenEXT;
|
|
|
2126 struct DrawIndirectCountIndirectCommandEXT;
|
|
|
2127 struct IndirectCommandsVertexBufferTokenEXT;
|
|
|
2128 struct BindVertexBufferIndirectCommandEXT;
|
|
|
2129 struct IndirectCommandsIndexBufferTokenEXT;
|
|
|
2130 struct BindIndexBufferIndirectCommandEXT;
|
|
|
2131 struct IndirectCommandsPushConstantTokenEXT;
|
|
|
2132 struct IndirectCommandsExecutionSetTokenEXT;
|
|
|
2133 union IndirectCommandsTokenDataEXT;
|
|
|
2134 struct IndirectExecutionSetShaderLayoutInfoEXT;
|
|
|
2135 struct GeneratedCommandsPipelineInfoEXT;
|
|
|
2136 struct GeneratedCommandsShaderInfoEXT;
|
|
|
2137 struct WriteIndirectExecutionSetShaderEXT;
|
|
|
2138
|
|
|
2139 //=== VK_KHR_maintenance8 ===
|
|
|
2140 struct MemoryBarrierAccessFlags3KHR;
|
|
|
2141 struct PhysicalDeviceMaintenance8FeaturesKHR;
|
|
|
2142
|
|
|
2143 //=== VK_MESA_image_alignment_control ===
|
|
|
2144 struct PhysicalDeviceImageAlignmentControlFeaturesMESA;
|
|
|
2145 struct PhysicalDeviceImageAlignmentControlPropertiesMESA;
|
|
|
2146 struct ImageAlignmentControlCreateInfoMESA;
|
|
|
2147
|
|
|
2148 //=== VK_KHR_shader_fma ===
|
|
|
2149 struct PhysicalDeviceShaderFmaFeaturesKHR;
|
|
|
2150
|
|
|
2151 //=== VK_EXT_ray_tracing_invocation_reorder ===
|
|
|
2152 struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT;
|
|
|
2153 struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT;
|
|
|
2154
|
|
|
2155 //=== VK_EXT_depth_clamp_control ===
|
|
|
2156 struct PhysicalDeviceDepthClampControlFeaturesEXT;
|
|
|
2157 struct PipelineViewportDepthClampControlCreateInfoEXT;
|
|
|
2158 struct DepthClampRangeEXT;
|
|
|
2159
|
|
|
2160 //=== VK_KHR_maintenance9 ===
|
|
|
2161 struct PhysicalDeviceMaintenance9FeaturesKHR;
|
|
|
2162 struct PhysicalDeviceMaintenance9PropertiesKHR;
|
|
|
2163 struct QueueFamilyOwnershipTransferPropertiesKHR;
|
|
|
2164
|
|
|
2165 //=== VK_KHR_video_maintenance2 ===
|
|
|
2166 struct PhysicalDeviceVideoMaintenance2FeaturesKHR;
|
|
|
2167 struct VideoDecodeH264InlineSessionParametersInfoKHR;
|
|
|
2168 struct VideoDecodeH265InlineSessionParametersInfoKHR;
|
|
|
2169 struct VideoDecodeAV1InlineSessionParametersInfoKHR;
|
|
|
2170
|
|
|
2171 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
2172 //=== VK_OHOS_surface ===
|
|
|
2173 struct SurfaceCreateInfoOHOS;
|
|
|
2174 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
2175
|
|
|
2176 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
2177 //=== VK_OHOS_native_buffer ===
|
|
|
2178 struct NativeBufferOHOS;
|
|
|
2179 struct SwapchainImageCreateInfoOHOS;
|
|
|
2180 struct PhysicalDevicePresentationPropertiesOHOS;
|
|
|
2181 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
2182
|
|
|
2183 //=== VK_HUAWEI_hdr_vivid ===
|
|
|
2184 struct PhysicalDeviceHdrVividFeaturesHUAWEI;
|
|
|
2185 struct HdrVividDynamicMetadataHUAWEI;
|
|
|
2186
|
|
|
2187 //=== VK_NV_cooperative_matrix2 ===
|
|
|
2188 struct CooperativeMatrixFlexibleDimensionsPropertiesNV;
|
|
|
2189 struct PhysicalDeviceCooperativeMatrix2FeaturesNV;
|
|
|
2190 struct PhysicalDeviceCooperativeMatrix2PropertiesNV;
|
|
|
2191
|
|
|
2192 //=== VK_ARM_pipeline_opacity_micromap ===
|
|
|
2193 struct PhysicalDevicePipelineOpacityMicromapFeaturesARM;
|
|
|
2194
|
|
|
2195 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
2196 //=== VK_EXT_external_memory_metal ===
|
|
|
2197 struct ImportMemoryMetalHandleInfoEXT;
|
|
|
2198 struct MemoryMetalHandlePropertiesEXT;
|
|
|
2199 struct MemoryGetMetalHandleInfoEXT;
|
|
|
2200 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
2201
|
|
|
2202 //=== VK_KHR_depth_clamp_zero_one ===
|
|
|
2203 struct PhysicalDeviceDepthClampZeroOneFeaturesKHR;
|
|
|
2204 using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR;
|
|
|
2205
|
|
|
2206 //=== VK_ARM_performance_counters_by_region ===
|
|
|
2207 struct PhysicalDevicePerformanceCountersByRegionFeaturesARM;
|
|
|
2208 struct PhysicalDevicePerformanceCountersByRegionPropertiesARM;
|
|
|
2209 struct PerformanceCounterARM;
|
|
|
2210 struct PerformanceCounterDescriptionARM;
|
|
|
2211 struct RenderPassPerformanceCountersByRegionBeginInfoARM;
|
|
|
2212
|
|
|
2213 //=== VK_EXT_vertex_attribute_robustness ===
|
|
|
2214 struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
|
|
|
2215
|
|
|
2216 //=== VK_ARM_format_pack ===
|
|
|
2217 struct PhysicalDeviceFormatPackFeaturesARM;
|
|
|
2218
|
|
|
2219 //=== VK_VALVE_fragment_density_map_layered ===
|
|
|
2220 struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
|
|
|
2221 struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
|
|
|
2222 struct PipelineFragmentDensityMapLayeredCreateInfoVALVE;
|
|
|
2223
|
|
|
2224 //=== VK_KHR_robustness2 ===
|
|
|
2225 struct PhysicalDeviceRobustness2FeaturesKHR;
|
|
|
2226 using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR;
|
|
|
2227 struct PhysicalDeviceRobustness2PropertiesKHR;
|
|
|
2228 using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR;
|
|
|
2229
|
|
|
2230 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
2231 //=== VK_NV_present_metering ===
|
|
|
2232 struct SetPresentConfigNV;
|
|
|
2233 struct PhysicalDevicePresentMeteringFeaturesNV;
|
|
|
2234 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
2235
|
|
|
2236 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
2237 struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
|
|
|
2238 using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
|
|
|
2239 struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
|
|
|
2240 using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
|
|
|
2241 struct RenderPassFragmentDensityMapOffsetEndInfoEXT;
|
|
|
2242 using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;
|
|
|
2243
|
|
|
2244 //=== VK_EXT_zero_initialize_device_memory ===
|
|
|
2245 struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT;
|
|
|
2246
|
|
|
2247 //=== VK_KHR_present_mode_fifo_latest_ready ===
|
|
|
2248 struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
|
|
|
2249 using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
|
|
|
2250
|
|
|
2251 //=== VK_EXT_shader_64bit_indexing ===
|
|
|
2252 struct PhysicalDeviceShader64BitIndexingFeaturesEXT;
|
|
|
2253
|
|
|
2254 //=== VK_EXT_custom_resolve ===
|
|
|
2255 struct PhysicalDeviceCustomResolveFeaturesEXT;
|
|
|
2256 struct BeginCustomResolveInfoEXT;
|
|
|
2257 struct CustomResolveCreateInfoEXT;
|
|
|
2258
|
|
|
2259 //=== VK_QCOM_data_graph_model ===
|
|
|
2260 struct PipelineCacheHeaderVersionDataGraphQCOM;
|
|
|
2261 struct DataGraphPipelineBuiltinModelCreateInfoQCOM;
|
|
|
2262 struct PhysicalDeviceDataGraphModelFeaturesQCOM;
|
|
|
2263
|
|
|
2264 //=== VK_KHR_maintenance10 ===
|
|
|
2265 struct PhysicalDeviceMaintenance10FeaturesKHR;
|
|
|
2266 struct PhysicalDeviceMaintenance10PropertiesKHR;
|
|
|
2267 struct RenderingEndInfoKHR;
|
|
|
2268 using RenderingEndInfoEXT = RenderingEndInfoKHR;
|
|
|
2269 struct RenderingAttachmentFlagsInfoKHR;
|
|
|
2270 struct ResolveImageModeInfoKHR;
|
|
|
2271
|
|
|
2272 //=== VK_SEC_pipeline_cache_incremental_mode ===
|
|
|
2273 struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC;
|
|
|
2274
|
|
|
2275 //=== VK_EXT_shader_uniform_buffer_unsized_array ===
|
|
|
2276 struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT;
|
|
|
2277
|
|
|
2278 //===================================
|
|
|
2279 //=== HANDLE forward declarations ===
|
|
|
2280 //===================================
|
|
|
2281
|
|
|
2282 //=== VK_VERSION_1_0 ===
|
|
|
2283 class Instance;
|
|
|
2284 class PhysicalDevice;
|
|
|
2285 class Device;
|
|
|
2286 class Queue;
|
|
|
2287 class DeviceMemory;
|
|
|
2288 class Fence;
|
|
|
2289 class Semaphore;
|
|
|
2290 class QueryPool;
|
|
|
2291 class Buffer;
|
|
|
2292 class Image;
|
|
|
2293 class ImageView;
|
|
|
2294 class CommandPool;
|
|
|
2295 class CommandBuffer;
|
|
|
2296 class Event;
|
|
|
2297 class BufferView;
|
|
|
2298 class ShaderModule;
|
|
|
2299 class PipelineCache;
|
|
|
2300 class Pipeline;
|
|
|
2301 class PipelineLayout;
|
|
|
2302 class Sampler;
|
|
|
2303 class DescriptorPool;
|
|
|
2304 class DescriptorSet;
|
|
|
2305 class DescriptorSetLayout;
|
|
|
2306 class Framebuffer;
|
|
|
2307 class RenderPass;
|
|
|
2308
|
|
|
2309 //=== VK_VERSION_1_1 ===
|
|
|
2310 class DescriptorUpdateTemplate;
|
|
|
2311 class SamplerYcbcrConversion;
|
|
|
2312
|
|
|
2313 //=== VK_VERSION_1_3 ===
|
|
|
2314 class PrivateDataSlot;
|
|
|
2315
|
|
|
2316 //=== VK_KHR_surface ===
|
|
|
2317 class SurfaceKHR;
|
|
|
2318
|
|
|
2319 //=== VK_KHR_swapchain ===
|
|
|
2320 class SwapchainKHR;
|
|
|
2321
|
|
|
2322 //=== VK_KHR_display ===
|
|
|
2323 class DisplayKHR;
|
|
|
2324 class DisplayModeKHR;
|
|
|
2325
|
|
|
2326 //=== VK_EXT_debug_report ===
|
|
|
2327 class DebugReportCallbackEXT;
|
|
|
2328
|
|
|
2329 //=== VK_KHR_video_queue ===
|
|
|
2330 class VideoSessionKHR;
|
|
|
2331 class VideoSessionParametersKHR;
|
|
|
2332
|
|
|
2333 //=== VK_NVX_binary_import ===
|
|
|
2334 class CuModuleNVX;
|
|
|
2335 class CuFunctionNVX;
|
|
|
2336
|
|
|
2337 //=== VK_EXT_debug_utils ===
|
|
|
2338 class DebugUtilsMessengerEXT;
|
|
|
2339
|
|
|
2340 //=== VK_KHR_acceleration_structure ===
|
|
|
2341 class AccelerationStructureKHR;
|
|
|
2342
|
|
|
2343 //=== VK_EXT_validation_cache ===
|
|
|
2344 class ValidationCacheEXT;
|
|
|
2345
|
|
|
2346 //=== VK_NV_ray_tracing ===
|
|
|
2347 class AccelerationStructureNV;
|
|
|
2348
|
|
|
2349 //=== VK_INTEL_performance_query ===
|
|
|
2350 class PerformanceConfigurationINTEL;
|
|
|
2351
|
|
|
2352 //=== VK_KHR_deferred_host_operations ===
|
|
|
2353 class DeferredOperationKHR;
|
|
|
2354
|
|
|
2355 //=== VK_NV_device_generated_commands ===
|
|
|
2356 class IndirectCommandsLayoutNV;
|
|
|
2357
|
|
|
2358 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
2359 //=== VK_NV_cuda_kernel_launch ===
|
|
|
2360 class CudaModuleNV;
|
|
|
2361 class CudaFunctionNV;
|
|
|
2362 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
2363
|
|
|
2364 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
2365 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
2366 class BufferCollectionFUCHSIA;
|
|
|
2367 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
2368
|
|
|
2369 //=== VK_EXT_opacity_micromap ===
|
|
|
2370 class MicromapEXT;
|
|
|
2371
|
|
|
2372 //=== VK_ARM_tensors ===
|
|
|
2373 class TensorARM;
|
|
|
2374 class TensorViewARM;
|
|
|
2375
|
|
|
2376 //=== VK_NV_optical_flow ===
|
|
|
2377 class OpticalFlowSessionNV;
|
|
|
2378
|
|
|
2379 //=== VK_EXT_shader_object ===
|
|
|
2380 class ShaderEXT;
|
|
|
2381
|
|
|
2382 //=== VK_KHR_pipeline_binary ===
|
|
|
2383 class PipelineBinaryKHR;
|
|
|
2384
|
|
|
2385 //=== VK_ARM_data_graph ===
|
|
|
2386 class DataGraphPipelineSessionARM;
|
|
|
2387
|
|
|
2388 //=== VK_NV_external_compute_queue ===
|
|
|
2389 class ExternalComputeQueueNV;
|
|
|
2390
|
|
|
2391 //=== VK_EXT_device_generated_commands ===
|
|
|
2392 class IndirectCommandsLayoutEXT;
|
|
|
2393 class IndirectExecutionSetEXT;
|
|
|
2394
|
|
|
2395 typedef void( VKAPI_PTR * PFN_VoidFunction )();
|
|
|
2396
|
|
|
2397 #ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
2398 //======================
|
|
|
2399 //=== UNIQUE HANDLEs ===
|
|
|
2400 //======================
|
|
|
2401
|
|
|
2402 //=== VK_VERSION_1_0 ===
|
|
|
2403 template <typename Dispatch>
|
|
|
2404 class UniqueHandleTraits<Instance, Dispatch>
|
|
|
2405 {
|
|
|
2406 public:
|
|
|
2407 using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
|
|
|
2408 };
|
|
|
2409
|
|
|
2410 using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2411
|
|
|
2412 template <typename Dispatch>
|
|
|
2413 class UniqueHandleTraits<Device, Dispatch>
|
|
|
2414 {
|
|
|
2415 public:
|
|
|
2416 using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
|
|
|
2417 };
|
|
|
2418
|
|
|
2419 using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2420
|
|
|
2421 template <typename Dispatch>
|
|
|
2422 class UniqueHandleTraits<DeviceMemory, Dispatch>
|
|
|
2423 {
|
|
|
2424 public:
|
|
|
2425 using deleter = detail::ObjectFree<Device, Dispatch>;
|
|
|
2426 };
|
|
|
2427
|
|
|
2428 using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2429
|
|
|
2430 template <typename Dispatch>
|
|
|
2431 class UniqueHandleTraits<Fence, Dispatch>
|
|
|
2432 {
|
|
|
2433 public:
|
|
|
2434 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2435 };
|
|
|
2436
|
|
|
2437 using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2438
|
|
|
2439 template <typename Dispatch>
|
|
|
2440 class UniqueHandleTraits<Semaphore, Dispatch>
|
|
|
2441 {
|
|
|
2442 public:
|
|
|
2443 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2444 };
|
|
|
2445
|
|
|
2446 using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2447
|
|
|
2448 template <typename Dispatch>
|
|
|
2449 class UniqueHandleTraits<QueryPool, Dispatch>
|
|
|
2450 {
|
|
|
2451 public:
|
|
|
2452 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2453 };
|
|
|
2454
|
|
|
2455 using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2456
|
|
|
2457 template <typename Dispatch>
|
|
|
2458 class UniqueHandleTraits<Buffer, Dispatch>
|
|
|
2459 {
|
|
|
2460 public:
|
|
|
2461 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2462 };
|
|
|
2463
|
|
|
2464 using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2465
|
|
|
2466 template <typename Dispatch>
|
|
|
2467 class UniqueHandleTraits<Image, Dispatch>
|
|
|
2468 {
|
|
|
2469 public:
|
|
|
2470 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2471 };
|
|
|
2472
|
|
|
2473 using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2474
|
|
|
2475 template <typename Dispatch>
|
|
|
2476 class UniqueHandleTraits<ImageView, Dispatch>
|
|
|
2477 {
|
|
|
2478 public:
|
|
|
2479 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2480 };
|
|
|
2481
|
|
|
2482 using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2483
|
|
|
2484 template <typename Dispatch>
|
|
|
2485 class UniqueHandleTraits<CommandPool, Dispatch>
|
|
|
2486 {
|
|
|
2487 public:
|
|
|
2488 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2489 };
|
|
|
2490
|
|
|
2491 using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2492
|
|
|
2493 template <typename Dispatch>
|
|
|
2494 class UniqueHandleTraits<CommandBuffer, Dispatch>
|
|
|
2495 {
|
|
|
2496 public:
|
|
|
2497 using deleter = detail::PoolFree<Device, CommandPool, Dispatch>;
|
|
|
2498 };
|
|
|
2499
|
|
|
2500 using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2501
|
|
|
2502 template <typename Dispatch>
|
|
|
2503 class UniqueHandleTraits<Event, Dispatch>
|
|
|
2504 {
|
|
|
2505 public:
|
|
|
2506 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2507 };
|
|
|
2508
|
|
|
2509 using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2510
|
|
|
2511 template <typename Dispatch>
|
|
|
2512 class UniqueHandleTraits<BufferView, Dispatch>
|
|
|
2513 {
|
|
|
2514 public:
|
|
|
2515 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2516 };
|
|
|
2517
|
|
|
2518 using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2519
|
|
|
2520 template <typename Dispatch>
|
|
|
2521 class UniqueHandleTraits<ShaderModule, Dispatch>
|
|
|
2522 {
|
|
|
2523 public:
|
|
|
2524 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2525 };
|
|
|
2526
|
|
|
2527 using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2528
|
|
|
2529 template <typename Dispatch>
|
|
|
2530 class UniqueHandleTraits<PipelineCache, Dispatch>
|
|
|
2531 {
|
|
|
2532 public:
|
|
|
2533 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2534 };
|
|
|
2535
|
|
|
2536 using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2537
|
|
|
2538 template <typename Dispatch>
|
|
|
2539 class UniqueHandleTraits<Pipeline, Dispatch>
|
|
|
2540 {
|
|
|
2541 public:
|
|
|
2542 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2543 };
|
|
|
2544
|
|
|
2545 using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2546
|
|
|
2547 template <typename Dispatch>
|
|
|
2548 class UniqueHandleTraits<PipelineLayout, Dispatch>
|
|
|
2549 {
|
|
|
2550 public:
|
|
|
2551 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2552 };
|
|
|
2553
|
|
|
2554 using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2555
|
|
|
2556 template <typename Dispatch>
|
|
|
2557 class UniqueHandleTraits<Sampler, Dispatch>
|
|
|
2558 {
|
|
|
2559 public:
|
|
|
2560 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2561 };
|
|
|
2562
|
|
|
2563 using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2564
|
|
|
2565 template <typename Dispatch>
|
|
|
2566 class UniqueHandleTraits<DescriptorPool, Dispatch>
|
|
|
2567 {
|
|
|
2568 public:
|
|
|
2569 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2570 };
|
|
|
2571
|
|
|
2572 using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2573
|
|
|
2574 template <typename Dispatch>
|
|
|
2575 class UniqueHandleTraits<DescriptorSet, Dispatch>
|
|
|
2576 {
|
|
|
2577 public:
|
|
|
2578 using deleter = detail::PoolFree<Device, DescriptorPool, Dispatch>;
|
|
|
2579 };
|
|
|
2580
|
|
|
2581 using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2582
|
|
|
2583 template <typename Dispatch>
|
|
|
2584 class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
|
|
|
2585 {
|
|
|
2586 public:
|
|
|
2587 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2588 };
|
|
|
2589
|
|
|
2590 using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2591
|
|
|
2592 template <typename Dispatch>
|
|
|
2593 class UniqueHandleTraits<Framebuffer, Dispatch>
|
|
|
2594 {
|
|
|
2595 public:
|
|
|
2596 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2597 };
|
|
|
2598
|
|
|
2599 using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2600
|
|
|
2601 template <typename Dispatch>
|
|
|
2602 class UniqueHandleTraits<RenderPass, Dispatch>
|
|
|
2603 {
|
|
|
2604 public:
|
|
|
2605 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2606 };
|
|
|
2607
|
|
|
2608 using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2609
|
|
|
2610 //=== VK_VERSION_1_1 ===
|
|
|
2611 template <typename Dispatch>
|
|
|
2612 class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
|
|
|
2613 {
|
|
|
2614 public:
|
|
|
2615 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2616 };
|
|
|
2617
|
|
|
2618 using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2619 using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2620
|
|
|
2621 template <typename Dispatch>
|
|
|
2622 class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
|
|
|
2623 {
|
|
|
2624 public:
|
|
|
2625 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2626 };
|
|
|
2627
|
|
|
2628 using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2629 using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2630
|
|
|
2631 //=== VK_VERSION_1_3 ===
|
|
|
2632 template <typename Dispatch>
|
|
|
2633 class UniqueHandleTraits<PrivateDataSlot, Dispatch>
|
|
|
2634 {
|
|
|
2635 public:
|
|
|
2636 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2637 };
|
|
|
2638
|
|
|
2639 using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2640 using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2641
|
|
|
2642 //=== VK_KHR_surface ===
|
|
|
2643 template <typename Dispatch>
|
|
|
2644 class UniqueHandleTraits<SurfaceKHR, Dispatch>
|
|
|
2645 {
|
|
|
2646 public:
|
|
|
2647 using deleter = detail::ObjectDestroy<Instance, Dispatch>;
|
|
|
2648 };
|
|
|
2649
|
|
|
2650 using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2651
|
|
|
2652 //=== VK_KHR_swapchain ===
|
|
|
2653 template <typename Dispatch>
|
|
|
2654 class UniqueHandleTraits<SwapchainKHR, Dispatch>
|
|
|
2655 {
|
|
|
2656 public:
|
|
|
2657 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2658 };
|
|
|
2659
|
|
|
2660 using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2661
|
|
|
2662 //=== VK_KHR_display ===
|
|
|
2663 template <typename Dispatch>
|
|
|
2664 class UniqueHandleTraits<DisplayKHR, Dispatch>
|
|
|
2665 {
|
|
|
2666 public:
|
|
|
2667 using deleter = detail::ObjectDestroy<PhysicalDevice, Dispatch>;
|
|
|
2668 };
|
|
|
2669
|
|
|
2670 using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2671
|
|
|
2672 //=== VK_EXT_debug_report ===
|
|
|
2673 template <typename Dispatch>
|
|
|
2674 class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
|
|
|
2675 {
|
|
|
2676 public:
|
|
|
2677 using deleter = detail::ObjectDestroy<Instance, Dispatch>;
|
|
|
2678 };
|
|
|
2679
|
|
|
2680 using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2681
|
|
|
2682 //=== VK_KHR_video_queue ===
|
|
|
2683 template <typename Dispatch>
|
|
|
2684 class UniqueHandleTraits<VideoSessionKHR, Dispatch>
|
|
|
2685 {
|
|
|
2686 public:
|
|
|
2687 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2688 };
|
|
|
2689
|
|
|
2690 using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2691
|
|
|
2692 template <typename Dispatch>
|
|
|
2693 class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
|
|
|
2694 {
|
|
|
2695 public:
|
|
|
2696 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2697 };
|
|
|
2698
|
|
|
2699 using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2700
|
|
|
2701 //=== VK_NVX_binary_import ===
|
|
|
2702 template <typename Dispatch>
|
|
|
2703 class UniqueHandleTraits<CuModuleNVX, Dispatch>
|
|
|
2704 {
|
|
|
2705 public:
|
|
|
2706 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2707 };
|
|
|
2708
|
|
|
2709 using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2710
|
|
|
2711 template <typename Dispatch>
|
|
|
2712 class UniqueHandleTraits<CuFunctionNVX, Dispatch>
|
|
|
2713 {
|
|
|
2714 public:
|
|
|
2715 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2716 };
|
|
|
2717
|
|
|
2718 using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2719
|
|
|
2720 //=== VK_EXT_debug_utils ===
|
|
|
2721 template <typename Dispatch>
|
|
|
2722 class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
|
|
|
2723 {
|
|
|
2724 public:
|
|
|
2725 using deleter = detail::ObjectDestroy<Instance, Dispatch>;
|
|
|
2726 };
|
|
|
2727
|
|
|
2728 using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2729
|
|
|
2730 //=== VK_KHR_acceleration_structure ===
|
|
|
2731 template <typename Dispatch>
|
|
|
2732 class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
|
|
|
2733 {
|
|
|
2734 public:
|
|
|
2735 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2736 };
|
|
|
2737
|
|
|
2738 using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2739
|
|
|
2740 //=== VK_EXT_validation_cache ===
|
|
|
2741 template <typename Dispatch>
|
|
|
2742 class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
|
|
|
2743 {
|
|
|
2744 public:
|
|
|
2745 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2746 };
|
|
|
2747
|
|
|
2748 using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2749
|
|
|
2750 //=== VK_NV_ray_tracing ===
|
|
|
2751 template <typename Dispatch>
|
|
|
2752 class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
|
|
|
2753 {
|
|
|
2754 public:
|
|
|
2755 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2756 };
|
|
|
2757
|
|
|
2758 using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2759
|
|
|
2760 //=== VK_INTEL_performance_query ===
|
|
|
2761 template <typename Dispatch>
|
|
|
2762 class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>
|
|
|
2763 {
|
|
|
2764 public:
|
|
|
2765 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2766 };
|
|
|
2767
|
|
|
2768 using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2769
|
|
|
2770 //=== VK_KHR_deferred_host_operations ===
|
|
|
2771 template <typename Dispatch>
|
|
|
2772 class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
|
|
|
2773 {
|
|
|
2774 public:
|
|
|
2775 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2776 };
|
|
|
2777
|
|
|
2778 using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2779
|
|
|
2780 //=== VK_NV_device_generated_commands ===
|
|
|
2781 template <typename Dispatch>
|
|
|
2782 class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
|
|
|
2783 {
|
|
|
2784 public:
|
|
|
2785 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2786 };
|
|
|
2787
|
|
|
2788 using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2789
|
|
|
2790 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
2791 //=== VK_NV_cuda_kernel_launch ===
|
|
|
2792 template <typename Dispatch>
|
|
|
2793 class UniqueHandleTraits<CudaModuleNV, Dispatch>
|
|
|
2794 {
|
|
|
2795 public:
|
|
|
2796 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2797 };
|
|
|
2798
|
|
|
2799 using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2800
|
|
|
2801 template <typename Dispatch>
|
|
|
2802 class UniqueHandleTraits<CudaFunctionNV, Dispatch>
|
|
|
2803 {
|
|
|
2804 public:
|
|
|
2805 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2806 };
|
|
|
2807
|
|
|
2808 using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2809 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
2810
|
|
|
2811 # if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
2812 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
2813 template <typename Dispatch>
|
|
|
2814 class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
|
|
|
2815 {
|
|
|
2816 public:
|
|
|
2817 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2818 };
|
|
|
2819
|
|
|
2820 using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2821 # endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
2822
|
|
|
2823 //=== VK_EXT_opacity_micromap ===
|
|
|
2824 template <typename Dispatch>
|
|
|
2825 class UniqueHandleTraits<MicromapEXT, Dispatch>
|
|
|
2826 {
|
|
|
2827 public:
|
|
|
2828 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2829 };
|
|
|
2830
|
|
|
2831 using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2832
|
|
|
2833 //=== VK_ARM_tensors ===
|
|
|
2834 template <typename Dispatch>
|
|
|
2835 class UniqueHandleTraits<TensorARM, Dispatch>
|
|
|
2836 {
|
|
|
2837 public:
|
|
|
2838 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2839 };
|
|
|
2840
|
|
|
2841 using UniqueTensorARM = UniqueHandle<TensorARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2842
|
|
|
2843 template <typename Dispatch>
|
|
|
2844 class UniqueHandleTraits<TensorViewARM, Dispatch>
|
|
|
2845 {
|
|
|
2846 public:
|
|
|
2847 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2848 };
|
|
|
2849
|
|
|
2850 using UniqueTensorViewARM = UniqueHandle<TensorViewARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2851
|
|
|
2852 //=== VK_NV_optical_flow ===
|
|
|
2853 template <typename Dispatch>
|
|
|
2854 class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
|
|
|
2855 {
|
|
|
2856 public:
|
|
|
2857 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2858 };
|
|
|
2859
|
|
|
2860 using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2861
|
|
|
2862 //=== VK_EXT_shader_object ===
|
|
|
2863 template <typename Dispatch>
|
|
|
2864 class UniqueHandleTraits<ShaderEXT, Dispatch>
|
|
|
2865 {
|
|
|
2866 public:
|
|
|
2867 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2868 };
|
|
|
2869
|
|
|
2870 using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2871
|
|
|
2872 //=== VK_KHR_pipeline_binary ===
|
|
|
2873 template <typename Dispatch>
|
|
|
2874 class UniqueHandleTraits<PipelineBinaryKHR, Dispatch>
|
|
|
2875 {
|
|
|
2876 public:
|
|
|
2877 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2878 };
|
|
|
2879
|
|
|
2880 using UniquePipelineBinaryKHR = UniqueHandle<PipelineBinaryKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2881
|
|
|
2882 //=== VK_ARM_data_graph ===
|
|
|
2883 template <typename Dispatch>
|
|
|
2884 class UniqueHandleTraits<DataGraphPipelineSessionARM, Dispatch>
|
|
|
2885 {
|
|
|
2886 public:
|
|
|
2887 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2888 };
|
|
|
2889
|
|
|
2890 using UniqueDataGraphPipelineSessionARM = UniqueHandle<DataGraphPipelineSessionARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2891
|
|
|
2892 //=== VK_NV_external_compute_queue ===
|
|
|
2893 template <typename Dispatch>
|
|
|
2894 class UniqueHandleTraits<ExternalComputeQueueNV, Dispatch>
|
|
|
2895 {
|
|
|
2896 public:
|
|
|
2897 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2898 };
|
|
|
2899
|
|
|
2900 using UniqueExternalComputeQueueNV = UniqueHandle<ExternalComputeQueueNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2901
|
|
|
2902 //=== VK_EXT_device_generated_commands ===
|
|
|
2903 template <typename Dispatch>
|
|
|
2904 class UniqueHandleTraits<IndirectCommandsLayoutEXT, Dispatch>
|
|
|
2905 {
|
|
|
2906 public:
|
|
|
2907 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2908 };
|
|
|
2909
|
|
|
2910 using UniqueIndirectCommandsLayoutEXT = UniqueHandle<IndirectCommandsLayoutEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2911
|
|
|
2912 template <typename Dispatch>
|
|
|
2913 class UniqueHandleTraits<IndirectExecutionSetEXT, Dispatch>
|
|
|
2914 {
|
|
|
2915 public:
|
|
|
2916 using deleter = detail::ObjectDestroy<Device, Dispatch>;
|
|
|
2917 };
|
|
|
2918
|
|
|
2919 using UniqueIndirectExecutionSetEXT = UniqueHandle<IndirectExecutionSetEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
|
|
|
2920 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
|
|
2921
|
|
|
2922 //===============
|
|
|
2923 //=== HANDLEs ===
|
|
|
2924 //===============
|
|
|
2925
|
|
|
2926 template <typename Type>
|
|
|
2927 struct isVulkanHandleType
|
|
|
2928 {
|
|
|
2929 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
|
|
|
2930 };
|
|
|
2931
|
|
|
2932 // wrapper class for handle VkSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceKHR.html
|
|
|
2933 class SurfaceKHR
|
|
|
2934 {
|
|
|
2935 public:
|
|
|
2936 using CType = VkSurfaceKHR;
|
|
|
2937 using NativeType = VkSurfaceKHR;
|
|
|
2938
|
|
|
2939 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR;
|
|
|
2940 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSurfaceKHR;
|
|
|
2941
|
|
|
2942 public:
|
|
|
2943 SurfaceKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
2944
|
|
|
2945 SurfaceKHR( SurfaceKHR const & rhs ) = default;
|
|
|
2946 SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;
|
|
|
2947
|
|
|
2948 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
2949 SurfaceKHR( SurfaceKHR && rhs ) = default;
|
|
|
2950 SurfaceKHR & operator=( SurfaceKHR && rhs ) = default;
|
|
|
2951 #else
|
|
|
2952 SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( exchange( rhs.m_surfaceKHR, {} ) ) {}
|
|
|
2953
|
|
|
2954 SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
2955 {
|
|
|
2956 m_surfaceKHR = exchange( rhs.m_surfaceKHR, {} );
|
|
|
2957 return *this;
|
|
|
2958 }
|
|
|
2959 #endif
|
|
|
2960
|
|
|
2961 VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
2962
|
|
|
2963 VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
|
|
|
2964
|
|
|
2965 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
2966 SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
2967 {
|
|
|
2968 m_surfaceKHR = surfaceKHR;
|
|
|
2969 return *this;
|
|
|
2970 }
|
|
|
2971 #endif
|
|
|
2972
|
|
|
2973 SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
2974 {
|
|
|
2975 m_surfaceKHR = {};
|
|
|
2976 return *this;
|
|
|
2977 }
|
|
|
2978
|
|
|
2979 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
2980 {
|
|
|
2981 return m_surfaceKHR;
|
|
|
2982 }
|
|
|
2983
|
|
|
2984 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
2985 {
|
|
|
2986 return m_surfaceKHR != VK_NULL_HANDLE;
|
|
|
2987 }
|
|
|
2988
|
|
|
2989 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
2990 {
|
|
|
2991 return m_surfaceKHR == VK_NULL_HANDLE;
|
|
|
2992 }
|
|
|
2993
|
|
|
2994 private:
|
|
|
2995 VkSurfaceKHR m_surfaceKHR = {};
|
|
|
2996 };
|
|
|
2997
|
|
|
2998 template <>
|
|
|
2999 struct CppType<ObjectType, ObjectType::eSurfaceKHR>
|
|
|
3000 {
|
|
|
3001 using Type = SurfaceKHR;
|
|
|
3002 };
|
|
|
3003
|
|
|
3004 template <>
|
|
|
3005 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSurfaceKHR>
|
|
|
3006 {
|
|
|
3007 using Type = SurfaceKHR;
|
|
|
3008 };
|
|
|
3009
|
|
|
3010 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3011 template <>
|
|
|
3012 struct CppType<VkSurfaceKHR, VK_NULL_HANDLE>
|
|
|
3013 {
|
|
|
3014 using Type = SurfaceKHR;
|
|
|
3015 };
|
|
|
3016 #endif
|
|
|
3017
|
|
|
3018 template <>
|
|
|
3019 struct isVulkanHandleType<SurfaceKHR>
|
|
|
3020 {
|
|
|
3021 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3022 };
|
|
|
3023
|
|
|
3024 // wrapper class for handle VkDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackEXT.html
|
|
|
3025 class DebugReportCallbackEXT
|
|
|
3026 {
|
|
|
3027 public:
|
|
|
3028 using CType = VkDebugReportCallbackEXT;
|
|
|
3029 using NativeType = VkDebugReportCallbackEXT;
|
|
|
3030
|
|
|
3031 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT;
|
|
|
3032 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
|
|
|
3033
|
|
|
3034 public:
|
|
|
3035 DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3036
|
|
|
3037 DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs ) = default;
|
|
|
3038 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default;
|
|
|
3039
|
|
|
3040 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3041 DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) = default;
|
|
|
3042 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default;
|
|
|
3043 #else
|
|
|
3044 DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( exchange( rhs.m_debugReportCallbackEXT, {} ) ) {}
|
|
|
3045
|
|
|
3046 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3047 {
|
|
|
3048 m_debugReportCallbackEXT = exchange( rhs.m_debugReportCallbackEXT, {} );
|
|
|
3049 return *this;
|
|
|
3050 }
|
|
|
3051 #endif
|
|
|
3052
|
|
|
3053 VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3054
|
|
|
3055 VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
3056 : m_debugReportCallbackEXT( debugReportCallbackEXT )
|
|
|
3057 {
|
|
|
3058 }
|
|
|
3059
|
|
|
3060 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3061 DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
3062 {
|
|
|
3063 m_debugReportCallbackEXT = debugReportCallbackEXT;
|
|
|
3064 return *this;
|
|
|
3065 }
|
|
|
3066 #endif
|
|
|
3067
|
|
|
3068 DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3069 {
|
|
|
3070 m_debugReportCallbackEXT = {};
|
|
|
3071 return *this;
|
|
|
3072 }
|
|
|
3073
|
|
|
3074 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
|
|
|
3075 {
|
|
|
3076 return m_debugReportCallbackEXT;
|
|
|
3077 }
|
|
|
3078
|
|
|
3079 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3080 {
|
|
|
3081 return m_debugReportCallbackEXT != VK_NULL_HANDLE;
|
|
|
3082 }
|
|
|
3083
|
|
|
3084 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3085 {
|
|
|
3086 return m_debugReportCallbackEXT == VK_NULL_HANDLE;
|
|
|
3087 }
|
|
|
3088
|
|
|
3089 private:
|
|
|
3090 VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
|
|
|
3091 };
|
|
|
3092
|
|
|
3093 template <>
|
|
|
3094 struct CppType<ObjectType, ObjectType::eDebugReportCallbackEXT>
|
|
|
3095 {
|
|
|
3096 using Type = DebugReportCallbackEXT;
|
|
|
3097 };
|
|
|
3098
|
|
|
3099 template <>
|
|
|
3100 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
|
|
|
3101 {
|
|
|
3102 using Type = DebugReportCallbackEXT;
|
|
|
3103 };
|
|
|
3104
|
|
|
3105 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3106 template <>
|
|
|
3107 struct CppType<VkDebugReportCallbackEXT, VK_NULL_HANDLE>
|
|
|
3108 {
|
|
|
3109 using Type = DebugReportCallbackEXT;
|
|
|
3110 };
|
|
|
3111 #endif
|
|
|
3112
|
|
|
3113 template <>
|
|
|
3114 struct isVulkanHandleType<DebugReportCallbackEXT>
|
|
|
3115 {
|
|
|
3116 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3117 };
|
|
|
3118
|
|
|
3119 // wrapper class for handle VkDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerEXT.html
|
|
|
3120 class DebugUtilsMessengerEXT
|
|
|
3121 {
|
|
|
3122 public:
|
|
|
3123 using CType = VkDebugUtilsMessengerEXT;
|
|
|
3124 using NativeType = VkDebugUtilsMessengerEXT;
|
|
|
3125
|
|
|
3126 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT;
|
|
|
3127 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
3128
|
|
|
3129 public:
|
|
|
3130 DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3131
|
|
|
3132 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default;
|
|
|
3133 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;
|
|
|
3134
|
|
|
3135 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3136 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default;
|
|
|
3137 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default;
|
|
|
3138 #else
|
|
|
3139 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) {}
|
|
|
3140
|
|
|
3141 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3142 {
|
|
|
3143 m_debugUtilsMessengerEXT = exchange( rhs.m_debugUtilsMessengerEXT, {} );
|
|
|
3144 return *this;
|
|
|
3145 }
|
|
|
3146 #endif
|
|
|
3147
|
|
|
3148 VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3149
|
|
|
3150 VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
3151 : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
|
|
|
3152 {
|
|
|
3153 }
|
|
|
3154
|
|
|
3155 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3156 DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
3157 {
|
|
|
3158 m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
|
|
|
3159 return *this;
|
|
|
3160 }
|
|
|
3161 #endif
|
|
|
3162
|
|
|
3163 DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3164 {
|
|
|
3165 m_debugUtilsMessengerEXT = {};
|
|
|
3166 return *this;
|
|
|
3167 }
|
|
|
3168
|
|
|
3169 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
|
|
|
3170 {
|
|
|
3171 return m_debugUtilsMessengerEXT;
|
|
|
3172 }
|
|
|
3173
|
|
|
3174 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3175 {
|
|
|
3176 return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
|
|
|
3177 }
|
|
|
3178
|
|
|
3179 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3180 {
|
|
|
3181 return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
|
|
|
3182 }
|
|
|
3183
|
|
|
3184 private:
|
|
|
3185 VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
|
|
|
3186 };
|
|
|
3187
|
|
|
3188 template <>
|
|
|
3189 struct CppType<ObjectType, ObjectType::eDebugUtilsMessengerEXT>
|
|
|
3190 {
|
|
|
3191 using Type = DebugUtilsMessengerEXT;
|
|
|
3192 };
|
|
|
3193
|
|
|
3194 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3195 template <>
|
|
|
3196 struct CppType<VkDebugUtilsMessengerEXT, VK_NULL_HANDLE>
|
|
|
3197 {
|
|
|
3198 using Type = DebugUtilsMessengerEXT;
|
|
|
3199 };
|
|
|
3200 #endif
|
|
|
3201
|
|
|
3202 template <>
|
|
|
3203 struct isVulkanHandleType<DebugUtilsMessengerEXT>
|
|
|
3204 {
|
|
|
3205 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3206 };
|
|
|
3207
|
|
|
3208 // wrapper class for handle VkDisplayKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayKHR.html
|
|
|
3209 class DisplayKHR
|
|
|
3210 {
|
|
|
3211 public:
|
|
|
3212 using CType = VkDisplayKHR;
|
|
|
3213 using NativeType = VkDisplayKHR;
|
|
|
3214
|
|
|
3215 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR;
|
|
|
3216 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayKHR;
|
|
|
3217
|
|
|
3218 public:
|
|
|
3219 DisplayKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3220
|
|
|
3221 DisplayKHR( DisplayKHR const & rhs ) = default;
|
|
|
3222 DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
|
|
|
3223
|
|
|
3224 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3225 DisplayKHR( DisplayKHR && rhs ) = default;
|
|
|
3226 DisplayKHR & operator=( DisplayKHR && rhs ) = default;
|
|
|
3227 #else
|
|
|
3228 DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayKHR( exchange( rhs.m_displayKHR, {} ) ) {}
|
|
|
3229
|
|
|
3230 DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3231 {
|
|
|
3232 m_displayKHR = exchange( rhs.m_displayKHR, {} );
|
|
|
3233 return *this;
|
|
|
3234 }
|
|
|
3235 #endif
|
|
|
3236
|
|
|
3237 VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3238
|
|
|
3239 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
|
|
|
3240
|
|
|
3241 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3242 DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
3243 {
|
|
|
3244 m_displayKHR = displayKHR;
|
|
|
3245 return *this;
|
|
|
3246 }
|
|
|
3247 #endif
|
|
|
3248
|
|
|
3249 DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3250 {
|
|
|
3251 m_displayKHR = {};
|
|
|
3252 return *this;
|
|
|
3253 }
|
|
|
3254
|
|
|
3255 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
3256 {
|
|
|
3257 return m_displayKHR;
|
|
|
3258 }
|
|
|
3259
|
|
|
3260 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3261 {
|
|
|
3262 return m_displayKHR != VK_NULL_HANDLE;
|
|
|
3263 }
|
|
|
3264
|
|
|
3265 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3266 {
|
|
|
3267 return m_displayKHR == VK_NULL_HANDLE;
|
|
|
3268 }
|
|
|
3269
|
|
|
3270 private:
|
|
|
3271 VkDisplayKHR m_displayKHR = {};
|
|
|
3272 };
|
|
|
3273
|
|
|
3274 template <>
|
|
|
3275 struct CppType<ObjectType, ObjectType::eDisplayKHR>
|
|
|
3276 {
|
|
|
3277 using Type = DisplayKHR;
|
|
|
3278 };
|
|
|
3279
|
|
|
3280 template <>
|
|
|
3281 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDisplayKHR>
|
|
|
3282 {
|
|
|
3283 using Type = DisplayKHR;
|
|
|
3284 };
|
|
|
3285
|
|
|
3286 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3287 template <>
|
|
|
3288 struct CppType<VkDisplayKHR, VK_NULL_HANDLE>
|
|
|
3289 {
|
|
|
3290 using Type = DisplayKHR;
|
|
|
3291 };
|
|
|
3292 #endif
|
|
|
3293
|
|
|
3294 template <>
|
|
|
3295 struct isVulkanHandleType<DisplayKHR>
|
|
|
3296 {
|
|
|
3297 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3298 };
|
|
|
3299
|
|
|
3300 // wrapper class for handle VkSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainKHR.html
|
|
|
3301 class SwapchainKHR
|
|
|
3302 {
|
|
|
3303 public:
|
|
|
3304 using CType = VkSwapchainKHR;
|
|
|
3305 using NativeType = VkSwapchainKHR;
|
|
|
3306
|
|
|
3307 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR;
|
|
|
3308 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSwapchainKHR;
|
|
|
3309
|
|
|
3310 public:
|
|
|
3311 SwapchainKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3312
|
|
|
3313 SwapchainKHR( SwapchainKHR const & rhs ) = default;
|
|
|
3314 SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;
|
|
|
3315
|
|
|
3316 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3317 SwapchainKHR( SwapchainKHR && rhs ) = default;
|
|
|
3318 SwapchainKHR & operator=( SwapchainKHR && rhs ) = default;
|
|
|
3319 #else
|
|
|
3320 SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( exchange( rhs.m_swapchainKHR, {} ) ) {}
|
|
|
3321
|
|
|
3322 SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3323 {
|
|
|
3324 m_swapchainKHR = exchange( rhs.m_swapchainKHR, {} );
|
|
|
3325 return *this;
|
|
|
3326 }
|
|
|
3327 #endif
|
|
|
3328
|
|
|
3329 VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3330
|
|
|
3331 VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
|
|
|
3332
|
|
|
3333 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3334 SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
3335 {
|
|
|
3336 m_swapchainKHR = swapchainKHR;
|
|
|
3337 return *this;
|
|
|
3338 }
|
|
|
3339 #endif
|
|
|
3340
|
|
|
3341 SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3342 {
|
|
|
3343 m_swapchainKHR = {};
|
|
|
3344 return *this;
|
|
|
3345 }
|
|
|
3346
|
|
|
3347 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
3348 {
|
|
|
3349 return m_swapchainKHR;
|
|
|
3350 }
|
|
|
3351
|
|
|
3352 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3353 {
|
|
|
3354 return m_swapchainKHR != VK_NULL_HANDLE;
|
|
|
3355 }
|
|
|
3356
|
|
|
3357 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3358 {
|
|
|
3359 return m_swapchainKHR == VK_NULL_HANDLE;
|
|
|
3360 }
|
|
|
3361
|
|
|
3362 private:
|
|
|
3363 VkSwapchainKHR m_swapchainKHR = {};
|
|
|
3364 };
|
|
|
3365
|
|
|
3366 template <>
|
|
|
3367 struct CppType<ObjectType, ObjectType::eSwapchainKHR>
|
|
|
3368 {
|
|
|
3369 using Type = SwapchainKHR;
|
|
|
3370 };
|
|
|
3371
|
|
|
3372 template <>
|
|
|
3373 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSwapchainKHR>
|
|
|
3374 {
|
|
|
3375 using Type = SwapchainKHR;
|
|
|
3376 };
|
|
|
3377
|
|
|
3378 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3379 template <>
|
|
|
3380 struct CppType<VkSwapchainKHR, VK_NULL_HANDLE>
|
|
|
3381 {
|
|
|
3382 using Type = SwapchainKHR;
|
|
|
3383 };
|
|
|
3384 #endif
|
|
|
3385
|
|
|
3386 template <>
|
|
|
3387 struct isVulkanHandleType<SwapchainKHR>
|
|
|
3388 {
|
|
|
3389 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3390 };
|
|
|
3391
|
|
|
3392 // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html
|
|
|
3393 class Image
|
|
|
3394 {
|
|
|
3395 public:
|
|
|
3396 using CType = VkImage;
|
|
|
3397 using NativeType = VkImage;
|
|
|
3398
|
|
|
3399 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
|
|
|
3400 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage;
|
|
|
3401
|
|
|
3402 public:
|
|
|
3403 Image() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3404
|
|
|
3405 Image( Image const & rhs ) = default;
|
|
|
3406 Image & operator=( Image const & rhs ) = default;
|
|
|
3407
|
|
|
3408 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3409 Image( Image && rhs ) = default;
|
|
|
3410 Image & operator=( Image && rhs ) = default;
|
|
|
3411 #else
|
|
|
3412 Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( exchange( rhs.m_image, {} ) ) {}
|
|
|
3413
|
|
|
3414 Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3415 {
|
|
|
3416 m_image = exchange( rhs.m_image, {} );
|
|
|
3417 return *this;
|
|
|
3418 }
|
|
|
3419 #endif
|
|
|
3420
|
|
|
3421 VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3422
|
|
|
3423 VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
|
|
|
3424
|
|
|
3425 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3426 Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
|
|
|
3427 {
|
|
|
3428 m_image = image;
|
|
|
3429 return *this;
|
|
|
3430 }
|
|
|
3431 #endif
|
|
|
3432
|
|
|
3433 Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3434 {
|
|
|
3435 m_image = {};
|
|
|
3436 return *this;
|
|
|
3437 }
|
|
|
3438
|
|
|
3439 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
|
|
|
3440 {
|
|
|
3441 return m_image;
|
|
|
3442 }
|
|
|
3443
|
|
|
3444 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3445 {
|
|
|
3446 return m_image != VK_NULL_HANDLE;
|
|
|
3447 }
|
|
|
3448
|
|
|
3449 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3450 {
|
|
|
3451 return m_image == VK_NULL_HANDLE;
|
|
|
3452 }
|
|
|
3453
|
|
|
3454 private:
|
|
|
3455 VkImage m_image = {};
|
|
|
3456 };
|
|
|
3457
|
|
|
3458 template <>
|
|
|
3459 struct CppType<ObjectType, ObjectType::eImage>
|
|
|
3460 {
|
|
|
3461 using Type = Image;
|
|
|
3462 };
|
|
|
3463
|
|
|
3464 template <>
|
|
|
3465 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eImage>
|
|
|
3466 {
|
|
|
3467 using Type = Image;
|
|
|
3468 };
|
|
|
3469
|
|
|
3470 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3471 template <>
|
|
|
3472 struct CppType<VkImage, VK_NULL_HANDLE>
|
|
|
3473 {
|
|
|
3474 using Type = Image;
|
|
|
3475 };
|
|
|
3476 #endif
|
|
|
3477
|
|
|
3478 template <>
|
|
|
3479 struct isVulkanHandleType<Image>
|
|
|
3480 {
|
|
|
3481 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3482 };
|
|
|
3483
|
|
|
3484 // wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html
|
|
|
3485 class Semaphore
|
|
|
3486 {
|
|
|
3487 public:
|
|
|
3488 using CType = VkSemaphore;
|
|
|
3489 using NativeType = VkSemaphore;
|
|
|
3490
|
|
|
3491 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore;
|
|
|
3492 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSemaphore;
|
|
|
3493
|
|
|
3494 public:
|
|
|
3495 Semaphore() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3496
|
|
|
3497 Semaphore( Semaphore const & rhs ) = default;
|
|
|
3498 Semaphore & operator=( Semaphore const & rhs ) = default;
|
|
|
3499
|
|
|
3500 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3501 Semaphore( Semaphore && rhs ) = default;
|
|
|
3502 Semaphore & operator=( Semaphore && rhs ) = default;
|
|
|
3503 #else
|
|
|
3504 Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT : m_semaphore( exchange( rhs.m_semaphore, {} ) ) {}
|
|
|
3505
|
|
|
3506 Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3507 {
|
|
|
3508 m_semaphore = exchange( rhs.m_semaphore, {} );
|
|
|
3509 return *this;
|
|
|
3510 }
|
|
|
3511 #endif
|
|
|
3512
|
|
|
3513 VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3514
|
|
|
3515 VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
|
|
|
3516
|
|
|
3517 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3518 Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
|
|
|
3519 {
|
|
|
3520 m_semaphore = semaphore;
|
|
|
3521 return *this;
|
|
|
3522 }
|
|
|
3523 #endif
|
|
|
3524
|
|
|
3525 Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3526 {
|
|
|
3527 m_semaphore = {};
|
|
|
3528 return *this;
|
|
|
3529 }
|
|
|
3530
|
|
|
3531 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
|
|
|
3532 {
|
|
|
3533 return m_semaphore;
|
|
|
3534 }
|
|
|
3535
|
|
|
3536 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3537 {
|
|
|
3538 return m_semaphore != VK_NULL_HANDLE;
|
|
|
3539 }
|
|
|
3540
|
|
|
3541 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3542 {
|
|
|
3543 return m_semaphore == VK_NULL_HANDLE;
|
|
|
3544 }
|
|
|
3545
|
|
|
3546 private:
|
|
|
3547 VkSemaphore m_semaphore = {};
|
|
|
3548 };
|
|
|
3549
|
|
|
3550 template <>
|
|
|
3551 struct CppType<ObjectType, ObjectType::eSemaphore>
|
|
|
3552 {
|
|
|
3553 using Type = Semaphore;
|
|
|
3554 };
|
|
|
3555
|
|
|
3556 template <>
|
|
|
3557 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSemaphore>
|
|
|
3558 {
|
|
|
3559 using Type = Semaphore;
|
|
|
3560 };
|
|
|
3561
|
|
|
3562 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3563 template <>
|
|
|
3564 struct CppType<VkSemaphore, VK_NULL_HANDLE>
|
|
|
3565 {
|
|
|
3566 using Type = Semaphore;
|
|
|
3567 };
|
|
|
3568 #endif
|
|
|
3569
|
|
|
3570 template <>
|
|
|
3571 struct isVulkanHandleType<Semaphore>
|
|
|
3572 {
|
|
|
3573 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3574 };
|
|
|
3575
|
|
|
3576 // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html
|
|
|
3577 class Fence
|
|
|
3578 {
|
|
|
3579 public:
|
|
|
3580 using CType = VkFence;
|
|
|
3581 using NativeType = VkFence;
|
|
|
3582
|
|
|
3583 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence;
|
|
|
3584 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFence;
|
|
|
3585
|
|
|
3586 public:
|
|
|
3587 Fence() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3588
|
|
|
3589 Fence( Fence const & rhs ) = default;
|
|
|
3590 Fence & operator=( Fence const & rhs ) = default;
|
|
|
3591
|
|
|
3592 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3593 Fence( Fence && rhs ) = default;
|
|
|
3594 Fence & operator=( Fence && rhs ) = default;
|
|
|
3595 #else
|
|
|
3596 Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT : m_fence( exchange( rhs.m_fence, {} ) ) {}
|
|
|
3597
|
|
|
3598 Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3599 {
|
|
|
3600 m_fence = exchange( rhs.m_fence, {} );
|
|
|
3601 return *this;
|
|
|
3602 }
|
|
|
3603 #endif
|
|
|
3604
|
|
|
3605 VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3606
|
|
|
3607 VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
|
|
|
3608
|
|
|
3609 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3610 Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
|
|
|
3611 {
|
|
|
3612 m_fence = fence;
|
|
|
3613 return *this;
|
|
|
3614 }
|
|
|
3615 #endif
|
|
|
3616
|
|
|
3617 Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3618 {
|
|
|
3619 m_fence = {};
|
|
|
3620 return *this;
|
|
|
3621 }
|
|
|
3622
|
|
|
3623 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
|
|
|
3624 {
|
|
|
3625 return m_fence;
|
|
|
3626 }
|
|
|
3627
|
|
|
3628 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3629 {
|
|
|
3630 return m_fence != VK_NULL_HANDLE;
|
|
|
3631 }
|
|
|
3632
|
|
|
3633 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3634 {
|
|
|
3635 return m_fence == VK_NULL_HANDLE;
|
|
|
3636 }
|
|
|
3637
|
|
|
3638 private:
|
|
|
3639 VkFence m_fence = {};
|
|
|
3640 };
|
|
|
3641
|
|
|
3642 template <>
|
|
|
3643 struct CppType<ObjectType, ObjectType::eFence>
|
|
|
3644 {
|
|
|
3645 using Type = Fence;
|
|
|
3646 };
|
|
|
3647
|
|
|
3648 template <>
|
|
|
3649 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eFence>
|
|
|
3650 {
|
|
|
3651 using Type = Fence;
|
|
|
3652 };
|
|
|
3653
|
|
|
3654 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3655 template <>
|
|
|
3656 struct CppType<VkFence, VK_NULL_HANDLE>
|
|
|
3657 {
|
|
|
3658 using Type = Fence;
|
|
|
3659 };
|
|
|
3660 #endif
|
|
|
3661
|
|
|
3662 template <>
|
|
|
3663 struct isVulkanHandleType<Fence>
|
|
|
3664 {
|
|
|
3665 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3666 };
|
|
|
3667
|
|
|
3668 // wrapper class for handle VkPerformanceConfigurationINTEL, see
|
|
|
3669 // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationINTEL.html
|
|
|
3670 class PerformanceConfigurationINTEL
|
|
|
3671 {
|
|
|
3672 public:
|
|
|
3673 using CType = VkPerformanceConfigurationINTEL;
|
|
|
3674 using NativeType = VkPerformanceConfigurationINTEL;
|
|
|
3675
|
|
|
3676 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL;
|
|
|
3677 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
3678
|
|
|
3679 public:
|
|
|
3680 PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3681
|
|
|
3682 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs ) = default;
|
|
|
3683 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default;
|
|
|
3684
|
|
|
3685 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3686 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) = default;
|
|
|
3687 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default;
|
|
|
3688 #else
|
|
|
3689 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3690 : m_performanceConfigurationINTEL( exchange( rhs.m_performanceConfigurationINTEL, {} ) )
|
|
|
3691 {
|
|
|
3692 }
|
|
|
3693
|
|
|
3694 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3695 {
|
|
|
3696 m_performanceConfigurationINTEL = exchange( rhs.m_performanceConfigurationINTEL, {} );
|
|
|
3697 return *this;
|
|
|
3698 }
|
|
|
3699 #endif
|
|
|
3700
|
|
|
3701 VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3702
|
|
|
3703 VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
|
|
|
3704 : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
|
|
|
3705 {
|
|
|
3706 }
|
|
|
3707
|
|
|
3708 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3709 PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
|
|
|
3710 {
|
|
|
3711 m_performanceConfigurationINTEL = performanceConfigurationINTEL;
|
|
|
3712 return *this;
|
|
|
3713 }
|
|
|
3714 #endif
|
|
|
3715
|
|
|
3716 PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3717 {
|
|
|
3718 m_performanceConfigurationINTEL = {};
|
|
|
3719 return *this;
|
|
|
3720 }
|
|
|
3721
|
|
|
3722 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
|
|
|
3723 {
|
|
|
3724 return m_performanceConfigurationINTEL;
|
|
|
3725 }
|
|
|
3726
|
|
|
3727 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3728 {
|
|
|
3729 return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
|
|
|
3730 }
|
|
|
3731
|
|
|
3732 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3733 {
|
|
|
3734 return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
|
|
|
3735 }
|
|
|
3736
|
|
|
3737 private:
|
|
|
3738 VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
|
|
|
3739 };
|
|
|
3740
|
|
|
3741 template <>
|
|
|
3742 struct CppType<ObjectType, ObjectType::ePerformanceConfigurationINTEL>
|
|
|
3743 {
|
|
|
3744 using Type = PerformanceConfigurationINTEL;
|
|
|
3745 };
|
|
|
3746
|
|
|
3747 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3748 template <>
|
|
|
3749 struct CppType<VkPerformanceConfigurationINTEL, VK_NULL_HANDLE>
|
|
|
3750 {
|
|
|
3751 using Type = PerformanceConfigurationINTEL;
|
|
|
3752 };
|
|
|
3753 #endif
|
|
|
3754
|
|
|
3755 template <>
|
|
|
3756 struct isVulkanHandleType<PerformanceConfigurationINTEL>
|
|
|
3757 {
|
|
|
3758 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3759 };
|
|
|
3760
|
|
|
3761 // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html
|
|
|
3762 class QueryPool
|
|
|
3763 {
|
|
|
3764 public:
|
|
|
3765 using CType = VkQueryPool;
|
|
|
3766 using NativeType = VkQueryPool;
|
|
|
3767
|
|
|
3768 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool;
|
|
|
3769 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueryPool;
|
|
|
3770
|
|
|
3771 public:
|
|
|
3772 QueryPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3773
|
|
|
3774 QueryPool( QueryPool const & rhs ) = default;
|
|
|
3775 QueryPool & operator=( QueryPool const & rhs ) = default;
|
|
|
3776
|
|
|
3777 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3778 QueryPool( QueryPool && rhs ) = default;
|
|
|
3779 QueryPool & operator=( QueryPool && rhs ) = default;
|
|
|
3780 #else
|
|
|
3781 QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT : m_queryPool( exchange( rhs.m_queryPool, {} ) ) {}
|
|
|
3782
|
|
|
3783 QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3784 {
|
|
|
3785 m_queryPool = exchange( rhs.m_queryPool, {} );
|
|
|
3786 return *this;
|
|
|
3787 }
|
|
|
3788 #endif
|
|
|
3789
|
|
|
3790 VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3791
|
|
|
3792 VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
|
|
|
3793
|
|
|
3794 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3795 QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
|
|
|
3796 {
|
|
|
3797 m_queryPool = queryPool;
|
|
|
3798 return *this;
|
|
|
3799 }
|
|
|
3800 #endif
|
|
|
3801
|
|
|
3802 QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3803 {
|
|
|
3804 m_queryPool = {};
|
|
|
3805 return *this;
|
|
|
3806 }
|
|
|
3807
|
|
|
3808 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
|
|
|
3809 {
|
|
|
3810 return m_queryPool;
|
|
|
3811 }
|
|
|
3812
|
|
|
3813 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3814 {
|
|
|
3815 return m_queryPool != VK_NULL_HANDLE;
|
|
|
3816 }
|
|
|
3817
|
|
|
3818 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3819 {
|
|
|
3820 return m_queryPool == VK_NULL_HANDLE;
|
|
|
3821 }
|
|
|
3822
|
|
|
3823 private:
|
|
|
3824 VkQueryPool m_queryPool = {};
|
|
|
3825 };
|
|
|
3826
|
|
|
3827 template <>
|
|
|
3828 struct CppType<ObjectType, ObjectType::eQueryPool>
|
|
|
3829 {
|
|
|
3830 using Type = QueryPool;
|
|
|
3831 };
|
|
|
3832
|
|
|
3833 template <>
|
|
|
3834 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eQueryPool>
|
|
|
3835 {
|
|
|
3836 using Type = QueryPool;
|
|
|
3837 };
|
|
|
3838
|
|
|
3839 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3840 template <>
|
|
|
3841 struct CppType<VkQueryPool, VK_NULL_HANDLE>
|
|
|
3842 {
|
|
|
3843 using Type = QueryPool;
|
|
|
3844 };
|
|
|
3845 #endif
|
|
|
3846
|
|
|
3847 template <>
|
|
|
3848 struct isVulkanHandleType<QueryPool>
|
|
|
3849 {
|
|
|
3850 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3851 };
|
|
|
3852
|
|
|
3853 // wrapper class for handle VkBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuffer.html
|
|
|
3854 class Buffer
|
|
|
3855 {
|
|
|
3856 public:
|
|
|
3857 using CType = VkBuffer;
|
|
|
3858 using NativeType = VkBuffer;
|
|
|
3859
|
|
|
3860 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer;
|
|
|
3861 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBuffer;
|
|
|
3862
|
|
|
3863 public:
|
|
|
3864 Buffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3865
|
|
|
3866 Buffer( Buffer const & rhs ) = default;
|
|
|
3867 Buffer & operator=( Buffer const & rhs ) = default;
|
|
|
3868
|
|
|
3869 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3870 Buffer( Buffer && rhs ) = default;
|
|
|
3871 Buffer & operator=( Buffer && rhs ) = default;
|
|
|
3872 #else
|
|
|
3873 Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT : m_buffer( exchange( rhs.m_buffer, {} ) ) {}
|
|
|
3874
|
|
|
3875 Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3876 {
|
|
|
3877 m_buffer = exchange( rhs.m_buffer, {} );
|
|
|
3878 return *this;
|
|
|
3879 }
|
|
|
3880 #endif
|
|
|
3881
|
|
|
3882 VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3883
|
|
|
3884 VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
|
|
|
3885
|
|
|
3886 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3887 Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
|
|
|
3888 {
|
|
|
3889 m_buffer = buffer;
|
|
|
3890 return *this;
|
|
|
3891 }
|
|
|
3892 #endif
|
|
|
3893
|
|
|
3894 Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3895 {
|
|
|
3896 m_buffer = {};
|
|
|
3897 return *this;
|
|
|
3898 }
|
|
|
3899
|
|
|
3900 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
|
|
|
3901 {
|
|
|
3902 return m_buffer;
|
|
|
3903 }
|
|
|
3904
|
|
|
3905 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3906 {
|
|
|
3907 return m_buffer != VK_NULL_HANDLE;
|
|
|
3908 }
|
|
|
3909
|
|
|
3910 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
3911 {
|
|
|
3912 return m_buffer == VK_NULL_HANDLE;
|
|
|
3913 }
|
|
|
3914
|
|
|
3915 private:
|
|
|
3916 VkBuffer m_buffer = {};
|
|
|
3917 };
|
|
|
3918
|
|
|
3919 template <>
|
|
|
3920 struct CppType<ObjectType, ObjectType::eBuffer>
|
|
|
3921 {
|
|
|
3922 using Type = Buffer;
|
|
|
3923 };
|
|
|
3924
|
|
|
3925 template <>
|
|
|
3926 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eBuffer>
|
|
|
3927 {
|
|
|
3928 using Type = Buffer;
|
|
|
3929 };
|
|
|
3930
|
|
|
3931 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
3932 template <>
|
|
|
3933 struct CppType<VkBuffer, VK_NULL_HANDLE>
|
|
|
3934 {
|
|
|
3935 using Type = Buffer;
|
|
|
3936 };
|
|
|
3937 #endif
|
|
|
3938
|
|
|
3939 template <>
|
|
|
3940 struct isVulkanHandleType<Buffer>
|
|
|
3941 {
|
|
|
3942 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
3943 };
|
|
|
3944
|
|
|
3945 // wrapper class for handle VkPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayout.html
|
|
|
3946 class PipelineLayout
|
|
|
3947 {
|
|
|
3948 public:
|
|
|
3949 using CType = VkPipelineLayout;
|
|
|
3950 using NativeType = VkPipelineLayout;
|
|
|
3951
|
|
|
3952 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout;
|
|
|
3953 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineLayout;
|
|
|
3954
|
|
|
3955 public:
|
|
|
3956 PipelineLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
3957
|
|
|
3958 PipelineLayout( PipelineLayout const & rhs ) = default;
|
|
|
3959 PipelineLayout & operator=( PipelineLayout const & rhs ) = default;
|
|
|
3960
|
|
|
3961 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
3962 PipelineLayout( PipelineLayout && rhs ) = default;
|
|
|
3963 PipelineLayout & operator=( PipelineLayout && rhs ) = default;
|
|
|
3964 #else
|
|
|
3965 PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( exchange( rhs.m_pipelineLayout, {} ) ) {}
|
|
|
3966
|
|
|
3967 PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
3968 {
|
|
|
3969 m_pipelineLayout = exchange( rhs.m_pipelineLayout, {} );
|
|
|
3970 return *this;
|
|
|
3971 }
|
|
|
3972 #endif
|
|
|
3973
|
|
|
3974 VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
3975
|
|
|
3976 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
|
|
|
3977
|
|
|
3978 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
3979 PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
|
|
|
3980 {
|
|
|
3981 m_pipelineLayout = pipelineLayout;
|
|
|
3982 return *this;
|
|
|
3983 }
|
|
|
3984 #endif
|
|
|
3985
|
|
|
3986 PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
3987 {
|
|
|
3988 m_pipelineLayout = {};
|
|
|
3989 return *this;
|
|
|
3990 }
|
|
|
3991
|
|
|
3992 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
|
|
|
3993 {
|
|
|
3994 return m_pipelineLayout;
|
|
|
3995 }
|
|
|
3996
|
|
|
3997 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
3998 {
|
|
|
3999 return m_pipelineLayout != VK_NULL_HANDLE;
|
|
|
4000 }
|
|
|
4001
|
|
|
4002 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4003 {
|
|
|
4004 return m_pipelineLayout == VK_NULL_HANDLE;
|
|
|
4005 }
|
|
|
4006
|
|
|
4007 private:
|
|
|
4008 VkPipelineLayout m_pipelineLayout = {};
|
|
|
4009 };
|
|
|
4010
|
|
|
4011 template <>
|
|
|
4012 struct CppType<ObjectType, ObjectType::ePipelineLayout>
|
|
|
4013 {
|
|
|
4014 using Type = PipelineLayout;
|
|
|
4015 };
|
|
|
4016
|
|
|
4017 template <>
|
|
|
4018 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePipelineLayout>
|
|
|
4019 {
|
|
|
4020 using Type = PipelineLayout;
|
|
|
4021 };
|
|
|
4022
|
|
|
4023 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4024 template <>
|
|
|
4025 struct CppType<VkPipelineLayout, VK_NULL_HANDLE>
|
|
|
4026 {
|
|
|
4027 using Type = PipelineLayout;
|
|
|
4028 };
|
|
|
4029 #endif
|
|
|
4030
|
|
|
4031 template <>
|
|
|
4032 struct isVulkanHandleType<PipelineLayout>
|
|
|
4033 {
|
|
|
4034 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4035 };
|
|
|
4036
|
|
|
4037 // wrapper class for handle VkDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSet.html
|
|
|
4038 class DescriptorSet
|
|
|
4039 {
|
|
|
4040 public:
|
|
|
4041 using CType = VkDescriptorSet;
|
|
|
4042 using NativeType = VkDescriptorSet;
|
|
|
4043
|
|
|
4044 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet;
|
|
|
4045 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSet;
|
|
|
4046
|
|
|
4047 public:
|
|
|
4048 DescriptorSet() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4049
|
|
|
4050 DescriptorSet( DescriptorSet const & rhs ) = default;
|
|
|
4051 DescriptorSet & operator=( DescriptorSet const & rhs ) = default;
|
|
|
4052
|
|
|
4053 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4054 DescriptorSet( DescriptorSet && rhs ) = default;
|
|
|
4055 DescriptorSet & operator=( DescriptorSet && rhs ) = default;
|
|
|
4056 #else
|
|
|
4057 DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( exchange( rhs.m_descriptorSet, {} ) ) {}
|
|
|
4058
|
|
|
4059 DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4060 {
|
|
|
4061 m_descriptorSet = exchange( rhs.m_descriptorSet, {} );
|
|
|
4062 return *this;
|
|
|
4063 }
|
|
|
4064 #endif
|
|
|
4065
|
|
|
4066 VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4067
|
|
|
4068 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
|
|
|
4069
|
|
|
4070 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4071 DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
|
|
|
4072 {
|
|
|
4073 m_descriptorSet = descriptorSet;
|
|
|
4074 return *this;
|
|
|
4075 }
|
|
|
4076 #endif
|
|
|
4077
|
|
|
4078 DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4079 {
|
|
|
4080 m_descriptorSet = {};
|
|
|
4081 return *this;
|
|
|
4082 }
|
|
|
4083
|
|
|
4084 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
|
|
|
4085 {
|
|
|
4086 return m_descriptorSet;
|
|
|
4087 }
|
|
|
4088
|
|
|
4089 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4090 {
|
|
|
4091 return m_descriptorSet != VK_NULL_HANDLE;
|
|
|
4092 }
|
|
|
4093
|
|
|
4094 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4095 {
|
|
|
4096 return m_descriptorSet == VK_NULL_HANDLE;
|
|
|
4097 }
|
|
|
4098
|
|
|
4099 private:
|
|
|
4100 VkDescriptorSet m_descriptorSet = {};
|
|
|
4101 };
|
|
|
4102
|
|
|
4103 template <>
|
|
|
4104 struct CppType<ObjectType, ObjectType::eDescriptorSet>
|
|
|
4105 {
|
|
|
4106 using Type = DescriptorSet;
|
|
|
4107 };
|
|
|
4108
|
|
|
4109 template <>
|
|
|
4110 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorSet>
|
|
|
4111 {
|
|
|
4112 using Type = DescriptorSet;
|
|
|
4113 };
|
|
|
4114
|
|
|
4115 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4116 template <>
|
|
|
4117 struct CppType<VkDescriptorSet, VK_NULL_HANDLE>
|
|
|
4118 {
|
|
|
4119 using Type = DescriptorSet;
|
|
|
4120 };
|
|
|
4121 #endif
|
|
|
4122
|
|
|
4123 template <>
|
|
|
4124 struct isVulkanHandleType<DescriptorSet>
|
|
|
4125 {
|
|
|
4126 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4127 };
|
|
|
4128
|
|
|
4129 // wrapper class for handle VkImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageView.html
|
|
|
4130 class ImageView
|
|
|
4131 {
|
|
|
4132 public:
|
|
|
4133 using CType = VkImageView;
|
|
|
4134 using NativeType = VkImageView;
|
|
|
4135
|
|
|
4136 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView;
|
|
|
4137 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImageView;
|
|
|
4138
|
|
|
4139 public:
|
|
|
4140 ImageView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4141
|
|
|
4142 ImageView( ImageView const & rhs ) = default;
|
|
|
4143 ImageView & operator=( ImageView const & rhs ) = default;
|
|
|
4144
|
|
|
4145 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4146 ImageView( ImageView && rhs ) = default;
|
|
|
4147 ImageView & operator=( ImageView && rhs ) = default;
|
|
|
4148 #else
|
|
|
4149 ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT : m_imageView( exchange( rhs.m_imageView, {} ) ) {}
|
|
|
4150
|
|
|
4151 ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4152 {
|
|
|
4153 m_imageView = exchange( rhs.m_imageView, {} );
|
|
|
4154 return *this;
|
|
|
4155 }
|
|
|
4156 #endif
|
|
|
4157
|
|
|
4158 VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4159
|
|
|
4160 VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
|
|
|
4161
|
|
|
4162 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4163 ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
|
|
|
4164 {
|
|
|
4165 m_imageView = imageView;
|
|
|
4166 return *this;
|
|
|
4167 }
|
|
|
4168 #endif
|
|
|
4169
|
|
|
4170 ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4171 {
|
|
|
4172 m_imageView = {};
|
|
|
4173 return *this;
|
|
|
4174 }
|
|
|
4175
|
|
|
4176 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
|
|
|
4177 {
|
|
|
4178 return m_imageView;
|
|
|
4179 }
|
|
|
4180
|
|
|
4181 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4182 {
|
|
|
4183 return m_imageView != VK_NULL_HANDLE;
|
|
|
4184 }
|
|
|
4185
|
|
|
4186 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4187 {
|
|
|
4188 return m_imageView == VK_NULL_HANDLE;
|
|
|
4189 }
|
|
|
4190
|
|
|
4191 private:
|
|
|
4192 VkImageView m_imageView = {};
|
|
|
4193 };
|
|
|
4194
|
|
|
4195 template <>
|
|
|
4196 struct CppType<ObjectType, ObjectType::eImageView>
|
|
|
4197 {
|
|
|
4198 using Type = ImageView;
|
|
|
4199 };
|
|
|
4200
|
|
|
4201 template <>
|
|
|
4202 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eImageView>
|
|
|
4203 {
|
|
|
4204 using Type = ImageView;
|
|
|
4205 };
|
|
|
4206
|
|
|
4207 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4208 template <>
|
|
|
4209 struct CppType<VkImageView, VK_NULL_HANDLE>
|
|
|
4210 {
|
|
|
4211 using Type = ImageView;
|
|
|
4212 };
|
|
|
4213 #endif
|
|
|
4214
|
|
|
4215 template <>
|
|
|
4216 struct isVulkanHandleType<ImageView>
|
|
|
4217 {
|
|
|
4218 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4219 };
|
|
|
4220
|
|
|
4221 // wrapper class for handle VkPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipeline.html
|
|
|
4222 class Pipeline
|
|
|
4223 {
|
|
|
4224 public:
|
|
|
4225 using CType = VkPipeline;
|
|
|
4226 using NativeType = VkPipeline;
|
|
|
4227
|
|
|
4228 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline;
|
|
|
4229 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipeline;
|
|
|
4230
|
|
|
4231 public:
|
|
|
4232 Pipeline() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4233
|
|
|
4234 Pipeline( Pipeline const & rhs ) = default;
|
|
|
4235 Pipeline & operator=( Pipeline const & rhs ) = default;
|
|
|
4236
|
|
|
4237 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4238 Pipeline( Pipeline && rhs ) = default;
|
|
|
4239 Pipeline & operator=( Pipeline && rhs ) = default;
|
|
|
4240 #else
|
|
|
4241 Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT : m_pipeline( exchange( rhs.m_pipeline, {} ) ) {}
|
|
|
4242
|
|
|
4243 Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4244 {
|
|
|
4245 m_pipeline = exchange( rhs.m_pipeline, {} );
|
|
|
4246 return *this;
|
|
|
4247 }
|
|
|
4248 #endif
|
|
|
4249
|
|
|
4250 VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4251
|
|
|
4252 VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
|
|
|
4253
|
|
|
4254 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4255 Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
|
|
|
4256 {
|
|
|
4257 m_pipeline = pipeline;
|
|
|
4258 return *this;
|
|
|
4259 }
|
|
|
4260 #endif
|
|
|
4261
|
|
|
4262 Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4263 {
|
|
|
4264 m_pipeline = {};
|
|
|
4265 return *this;
|
|
|
4266 }
|
|
|
4267
|
|
|
4268 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
|
|
|
4269 {
|
|
|
4270 return m_pipeline;
|
|
|
4271 }
|
|
|
4272
|
|
|
4273 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4274 {
|
|
|
4275 return m_pipeline != VK_NULL_HANDLE;
|
|
|
4276 }
|
|
|
4277
|
|
|
4278 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4279 {
|
|
|
4280 return m_pipeline == VK_NULL_HANDLE;
|
|
|
4281 }
|
|
|
4282
|
|
|
4283 private:
|
|
|
4284 VkPipeline m_pipeline = {};
|
|
|
4285 };
|
|
|
4286
|
|
|
4287 template <>
|
|
|
4288 struct CppType<ObjectType, ObjectType::ePipeline>
|
|
|
4289 {
|
|
|
4290 using Type = Pipeline;
|
|
|
4291 };
|
|
|
4292
|
|
|
4293 template <>
|
|
|
4294 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePipeline>
|
|
|
4295 {
|
|
|
4296 using Type = Pipeline;
|
|
|
4297 };
|
|
|
4298
|
|
|
4299 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4300 template <>
|
|
|
4301 struct CppType<VkPipeline, VK_NULL_HANDLE>
|
|
|
4302 {
|
|
|
4303 using Type = Pipeline;
|
|
|
4304 };
|
|
|
4305 #endif
|
|
|
4306
|
|
|
4307 template <>
|
|
|
4308 struct isVulkanHandleType<Pipeline>
|
|
|
4309 {
|
|
|
4310 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4311 };
|
|
|
4312
|
|
|
4313 // wrapper class for handle VkShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html
|
|
|
4314 class ShaderEXT
|
|
|
4315 {
|
|
|
4316 public:
|
|
|
4317 using CType = VkShaderEXT;
|
|
|
4318 using NativeType = VkShaderEXT;
|
|
|
4319
|
|
|
4320 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderEXT;
|
|
|
4321 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
4322
|
|
|
4323 public:
|
|
|
4324 ShaderEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4325
|
|
|
4326 ShaderEXT( ShaderEXT const & rhs ) = default;
|
|
|
4327 ShaderEXT & operator=( ShaderEXT const & rhs ) = default;
|
|
|
4328
|
|
|
4329 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4330 ShaderEXT( ShaderEXT && rhs ) = default;
|
|
|
4331 ShaderEXT & operator=( ShaderEXT && rhs ) = default;
|
|
|
4332 #else
|
|
|
4333 ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( exchange( rhs.m_shaderEXT, {} ) ) {}
|
|
|
4334
|
|
|
4335 ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4336 {
|
|
|
4337 m_shaderEXT = exchange( rhs.m_shaderEXT, {} );
|
|
|
4338 return *this;
|
|
|
4339 }
|
|
|
4340 #endif
|
|
|
4341
|
|
|
4342 VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4343
|
|
|
4344 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}
|
|
|
4345
|
|
|
4346 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4347 ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
4348 {
|
|
|
4349 m_shaderEXT = shaderEXT;
|
|
|
4350 return *this;
|
|
|
4351 }
|
|
|
4352 #endif
|
|
|
4353
|
|
|
4354 ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4355 {
|
|
|
4356 m_shaderEXT = {};
|
|
|
4357 return *this;
|
|
|
4358 }
|
|
|
4359
|
|
|
4360 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT
|
|
|
4361 {
|
|
|
4362 return m_shaderEXT;
|
|
|
4363 }
|
|
|
4364
|
|
|
4365 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4366 {
|
|
|
4367 return m_shaderEXT != VK_NULL_HANDLE;
|
|
|
4368 }
|
|
|
4369
|
|
|
4370 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4371 {
|
|
|
4372 return m_shaderEXT == VK_NULL_HANDLE;
|
|
|
4373 }
|
|
|
4374
|
|
|
4375 private:
|
|
|
4376 VkShaderEXT m_shaderEXT = {};
|
|
|
4377 };
|
|
|
4378
|
|
|
4379 template <>
|
|
|
4380 struct CppType<ObjectType, ObjectType::eShaderEXT>
|
|
|
4381 {
|
|
|
4382 using Type = ShaderEXT;
|
|
|
4383 };
|
|
|
4384
|
|
|
4385 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4386 template <>
|
|
|
4387 struct CppType<VkShaderEXT, VK_NULL_HANDLE>
|
|
|
4388 {
|
|
|
4389 using Type = ShaderEXT;
|
|
|
4390 };
|
|
|
4391 #endif
|
|
|
4392
|
|
|
4393 template <>
|
|
|
4394 struct isVulkanHandleType<ShaderEXT>
|
|
|
4395 {
|
|
|
4396 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4397 };
|
|
|
4398
|
|
|
4399 // wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html
|
|
|
4400 class AccelerationStructureNV
|
|
|
4401 {
|
|
|
4402 public:
|
|
|
4403 using CType = VkAccelerationStructureNV;
|
|
|
4404 using NativeType = VkAccelerationStructureNV;
|
|
|
4405
|
|
|
4406 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV;
|
|
|
4407 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureNV;
|
|
|
4408
|
|
|
4409 public:
|
|
|
4410 AccelerationStructureNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4411
|
|
|
4412 AccelerationStructureNV( AccelerationStructureNV const & rhs ) = default;
|
|
|
4413 AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default;
|
|
|
4414
|
|
|
4415 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4416 AccelerationStructureNV( AccelerationStructureNV && rhs ) = default;
|
|
|
4417 AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default;
|
|
|
4418 #else
|
|
|
4419 AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT : m_accelerationStructureNV( exchange( rhs.m_accelerationStructureNV, {} ) )
|
|
|
4420 {
|
|
|
4421 }
|
|
|
4422
|
|
|
4423 AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4424 {
|
|
|
4425 m_accelerationStructureNV = exchange( rhs.m_accelerationStructureNV, {} );
|
|
|
4426 return *this;
|
|
|
4427 }
|
|
|
4428 #endif
|
|
|
4429
|
|
|
4430 VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4431
|
|
|
4432 VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
|
|
|
4433 : m_accelerationStructureNV( accelerationStructureNV )
|
|
|
4434 {
|
|
|
4435 }
|
|
|
4436
|
|
|
4437 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4438 AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
|
|
|
4439 {
|
|
|
4440 m_accelerationStructureNV = accelerationStructureNV;
|
|
|
4441 return *this;
|
|
|
4442 }
|
|
|
4443 #endif
|
|
|
4444
|
|
|
4445 AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4446 {
|
|
|
4447 m_accelerationStructureNV = {};
|
|
|
4448 return *this;
|
|
|
4449 }
|
|
|
4450
|
|
|
4451 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
|
|
|
4452 {
|
|
|
4453 return m_accelerationStructureNV;
|
|
|
4454 }
|
|
|
4455
|
|
|
4456 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4457 {
|
|
|
4458 return m_accelerationStructureNV != VK_NULL_HANDLE;
|
|
|
4459 }
|
|
|
4460
|
|
|
4461 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4462 {
|
|
|
4463 return m_accelerationStructureNV == VK_NULL_HANDLE;
|
|
|
4464 }
|
|
|
4465
|
|
|
4466 private:
|
|
|
4467 VkAccelerationStructureNV m_accelerationStructureNV = {};
|
|
|
4468 };
|
|
|
4469
|
|
|
4470 template <>
|
|
|
4471 struct CppType<ObjectType, ObjectType::eAccelerationStructureNV>
|
|
|
4472 {
|
|
|
4473 using Type = AccelerationStructureNV;
|
|
|
4474 };
|
|
|
4475
|
|
|
4476 template <>
|
|
|
4477 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eAccelerationStructureNV>
|
|
|
4478 {
|
|
|
4479 using Type = AccelerationStructureNV;
|
|
|
4480 };
|
|
|
4481
|
|
|
4482 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4483 template <>
|
|
|
4484 struct CppType<VkAccelerationStructureNV, VK_NULL_HANDLE>
|
|
|
4485 {
|
|
|
4486 using Type = AccelerationStructureNV;
|
|
|
4487 };
|
|
|
4488 #endif
|
|
|
4489
|
|
|
4490 template <>
|
|
|
4491 struct isVulkanHandleType<AccelerationStructureNV>
|
|
|
4492 {
|
|
|
4493 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4494 };
|
|
|
4495
|
|
|
4496 // wrapper class for handle VkDataGraphPipelineSessionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionARM.html
|
|
|
4497 class DataGraphPipelineSessionARM
|
|
|
4498 {
|
|
|
4499 public:
|
|
|
4500 using CType = VkDataGraphPipelineSessionARM;
|
|
|
4501 using NativeType = VkDataGraphPipelineSessionARM;
|
|
|
4502
|
|
|
4503 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDataGraphPipelineSessionARM;
|
|
|
4504 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
4505
|
|
|
4506 public:
|
|
|
4507 DataGraphPipelineSessionARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4508
|
|
|
4509 DataGraphPipelineSessionARM( DataGraphPipelineSessionARM const & rhs ) = default;
|
|
|
4510 DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM const & rhs ) = default;
|
|
|
4511
|
|
|
4512 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4513 DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) = default;
|
|
|
4514 DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) = default;
|
|
|
4515 #else
|
|
|
4516 DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4517 : m_dataGraphPipelineSessionARM( exchange( rhs.m_dataGraphPipelineSessionARM, {} ) )
|
|
|
4518 {
|
|
|
4519 }
|
|
|
4520
|
|
|
4521 DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4522 {
|
|
|
4523 m_dataGraphPipelineSessionARM = exchange( rhs.m_dataGraphPipelineSessionARM, {} );
|
|
|
4524 return *this;
|
|
|
4525 }
|
|
|
4526 #endif
|
|
|
4527
|
|
|
4528 VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4529
|
|
|
4530 VULKAN_HPP_TYPESAFE_EXPLICIT DataGraphPipelineSessionARM( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT
|
|
|
4531 : m_dataGraphPipelineSessionARM( dataGraphPipelineSessionARM )
|
|
|
4532 {
|
|
|
4533 }
|
|
|
4534
|
|
|
4535 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4536 DataGraphPipelineSessionARM & operator=( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT
|
|
|
4537 {
|
|
|
4538 m_dataGraphPipelineSessionARM = dataGraphPipelineSessionARM;
|
|
|
4539 return *this;
|
|
|
4540 }
|
|
|
4541 #endif
|
|
|
4542
|
|
|
4543 DataGraphPipelineSessionARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4544 {
|
|
|
4545 m_dataGraphPipelineSessionARM = {};
|
|
|
4546 return *this;
|
|
|
4547 }
|
|
|
4548
|
|
|
4549 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDataGraphPipelineSessionARM() const VULKAN_HPP_NOEXCEPT
|
|
|
4550 {
|
|
|
4551 return m_dataGraphPipelineSessionARM;
|
|
|
4552 }
|
|
|
4553
|
|
|
4554 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4555 {
|
|
|
4556 return m_dataGraphPipelineSessionARM != VK_NULL_HANDLE;
|
|
|
4557 }
|
|
|
4558
|
|
|
4559 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4560 {
|
|
|
4561 return m_dataGraphPipelineSessionARM == VK_NULL_HANDLE;
|
|
|
4562 }
|
|
|
4563
|
|
|
4564 private:
|
|
|
4565 VkDataGraphPipelineSessionARM m_dataGraphPipelineSessionARM = {};
|
|
|
4566 };
|
|
|
4567
|
|
|
4568 template <>
|
|
|
4569 struct CppType<ObjectType, ObjectType::eDataGraphPipelineSessionARM>
|
|
|
4570 {
|
|
|
4571 using Type = DataGraphPipelineSessionARM;
|
|
|
4572 };
|
|
|
4573
|
|
|
4574 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4575 template <>
|
|
|
4576 struct CppType<VkDataGraphPipelineSessionARM, VK_NULL_HANDLE>
|
|
|
4577 {
|
|
|
4578 using Type = DataGraphPipelineSessionARM;
|
|
|
4579 };
|
|
|
4580 #endif
|
|
|
4581
|
|
|
4582 template <>
|
|
|
4583 struct isVulkanHandleType<DataGraphPipelineSessionARM>
|
|
|
4584 {
|
|
|
4585 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4586 };
|
|
|
4587
|
|
|
4588 // wrapper class for handle VkOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionNV.html
|
|
|
4589 class OpticalFlowSessionNV
|
|
|
4590 {
|
|
|
4591 public:
|
|
|
4592 using CType = VkOpticalFlowSessionNV;
|
|
|
4593 using NativeType = VkOpticalFlowSessionNV;
|
|
|
4594
|
|
|
4595 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eOpticalFlowSessionNV;
|
|
|
4596 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
4597
|
|
|
4598 public:
|
|
|
4599 OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4600
|
|
|
4601 OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs ) = default;
|
|
|
4602 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default;
|
|
|
4603
|
|
|
4604 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4605 OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) = default;
|
|
|
4606 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default;
|
|
|
4607 #else
|
|
|
4608 OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_opticalFlowSessionNV( exchange( rhs.m_opticalFlowSessionNV, {} ) ) {}
|
|
|
4609
|
|
|
4610 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4611 {
|
|
|
4612 m_opticalFlowSessionNV = exchange( rhs.m_opticalFlowSessionNV, {} );
|
|
|
4613 return *this;
|
|
|
4614 }
|
|
|
4615 #endif
|
|
|
4616
|
|
|
4617 VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4618
|
|
|
4619 VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
|
|
|
4620 : m_opticalFlowSessionNV( opticalFlowSessionNV )
|
|
|
4621 {
|
|
|
4622 }
|
|
|
4623
|
|
|
4624 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4625 OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
|
|
|
4626 {
|
|
|
4627 m_opticalFlowSessionNV = opticalFlowSessionNV;
|
|
|
4628 return *this;
|
|
|
4629 }
|
|
|
4630 #endif
|
|
|
4631
|
|
|
4632 OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4633 {
|
|
|
4634 m_opticalFlowSessionNV = {};
|
|
|
4635 return *this;
|
|
|
4636 }
|
|
|
4637
|
|
|
4638 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
|
|
|
4639 {
|
|
|
4640 return m_opticalFlowSessionNV;
|
|
|
4641 }
|
|
|
4642
|
|
|
4643 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4644 {
|
|
|
4645 return m_opticalFlowSessionNV != VK_NULL_HANDLE;
|
|
|
4646 }
|
|
|
4647
|
|
|
4648 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4649 {
|
|
|
4650 return m_opticalFlowSessionNV == VK_NULL_HANDLE;
|
|
|
4651 }
|
|
|
4652
|
|
|
4653 private:
|
|
|
4654 VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
|
|
|
4655 };
|
|
|
4656
|
|
|
4657 template <>
|
|
|
4658 struct CppType<ObjectType, ObjectType::eOpticalFlowSessionNV>
|
|
|
4659 {
|
|
|
4660 using Type = OpticalFlowSessionNV;
|
|
|
4661 };
|
|
|
4662
|
|
|
4663 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4664 template <>
|
|
|
4665 struct CppType<VkOpticalFlowSessionNV, VK_NULL_HANDLE>
|
|
|
4666 {
|
|
|
4667 using Type = OpticalFlowSessionNV;
|
|
|
4668 };
|
|
|
4669 #endif
|
|
|
4670
|
|
|
4671 template <>
|
|
|
4672 struct isVulkanHandleType<OpticalFlowSessionNV>
|
|
|
4673 {
|
|
|
4674 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4675 };
|
|
|
4676
|
|
|
4677 // wrapper class for handle VkDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplate.html
|
|
|
4678 class DescriptorUpdateTemplate
|
|
|
4679 {
|
|
|
4680 public:
|
|
|
4681 using CType = VkDescriptorUpdateTemplate;
|
|
|
4682 using NativeType = VkDescriptorUpdateTemplate;
|
|
|
4683
|
|
|
4684 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate;
|
|
|
4685 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
|
|
|
4686
|
|
|
4687 public:
|
|
|
4688 DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4689
|
|
|
4690 DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs ) = default;
|
|
|
4691 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default;
|
|
|
4692
|
|
|
4693 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4694 DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) = default;
|
|
|
4695 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default;
|
|
|
4696 #else
|
|
|
4697 DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4698 : m_descriptorUpdateTemplate( exchange( rhs.m_descriptorUpdateTemplate, {} ) )
|
|
|
4699 {
|
|
|
4700 }
|
|
|
4701
|
|
|
4702 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4703 {
|
|
|
4704 m_descriptorUpdateTemplate = exchange( rhs.m_descriptorUpdateTemplate, {} );
|
|
|
4705 return *this;
|
|
|
4706 }
|
|
|
4707 #endif
|
|
|
4708
|
|
|
4709 VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4710
|
|
|
4711 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
|
|
|
4712 : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
|
|
|
4713 {
|
|
|
4714 }
|
|
|
4715
|
|
|
4716 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4717 DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
|
|
|
4718 {
|
|
|
4719 m_descriptorUpdateTemplate = descriptorUpdateTemplate;
|
|
|
4720 return *this;
|
|
|
4721 }
|
|
|
4722 #endif
|
|
|
4723
|
|
|
4724 DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4725 {
|
|
|
4726 m_descriptorUpdateTemplate = {};
|
|
|
4727 return *this;
|
|
|
4728 }
|
|
|
4729
|
|
|
4730 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
|
|
|
4731 {
|
|
|
4732 return m_descriptorUpdateTemplate;
|
|
|
4733 }
|
|
|
4734
|
|
|
4735 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4736 {
|
|
|
4737 return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
|
|
|
4738 }
|
|
|
4739
|
|
|
4740 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4741 {
|
|
|
4742 return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
|
|
|
4743 }
|
|
|
4744
|
|
|
4745 private:
|
|
|
4746 VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
|
|
|
4747 };
|
|
|
4748
|
|
|
4749 template <>
|
|
|
4750 struct CppType<ObjectType, ObjectType::eDescriptorUpdateTemplate>
|
|
|
4751 {
|
|
|
4752 using Type = DescriptorUpdateTemplate;
|
|
|
4753 };
|
|
|
4754
|
|
|
4755 template <>
|
|
|
4756 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
|
|
|
4757 {
|
|
|
4758 using Type = DescriptorUpdateTemplate;
|
|
|
4759 };
|
|
|
4760
|
|
|
4761 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4762 template <>
|
|
|
4763 struct CppType<VkDescriptorUpdateTemplate, VK_NULL_HANDLE>
|
|
|
4764 {
|
|
|
4765 using Type = DescriptorUpdateTemplate;
|
|
|
4766 };
|
|
|
4767 #endif
|
|
|
4768
|
|
|
4769 template <>
|
|
|
4770 struct isVulkanHandleType<DescriptorUpdateTemplate>
|
|
|
4771 {
|
|
|
4772 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4773 };
|
|
|
4774
|
|
|
4775 using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
|
|
|
4776
|
|
|
4777 // wrapper class for handle VkEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEvent.html
|
|
|
4778 class Event
|
|
|
4779 {
|
|
|
4780 public:
|
|
|
4781 using CType = VkEvent;
|
|
|
4782 using NativeType = VkEvent;
|
|
|
4783
|
|
|
4784 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent;
|
|
|
4785 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eEvent;
|
|
|
4786
|
|
|
4787 public:
|
|
|
4788 Event() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4789
|
|
|
4790 Event( Event const & rhs ) = default;
|
|
|
4791 Event & operator=( Event const & rhs ) = default;
|
|
|
4792
|
|
|
4793 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4794 Event( Event && rhs ) = default;
|
|
|
4795 Event & operator=( Event && rhs ) = default;
|
|
|
4796 #else
|
|
|
4797 Event( Event && rhs ) VULKAN_HPP_NOEXCEPT : m_event( exchange( rhs.m_event, {} ) ) {}
|
|
|
4798
|
|
|
4799 Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4800 {
|
|
|
4801 m_event = exchange( rhs.m_event, {} );
|
|
|
4802 return *this;
|
|
|
4803 }
|
|
|
4804 #endif
|
|
|
4805
|
|
|
4806 VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4807
|
|
|
4808 VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
|
|
|
4809
|
|
|
4810 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4811 Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
|
|
|
4812 {
|
|
|
4813 m_event = event;
|
|
|
4814 return *this;
|
|
|
4815 }
|
|
|
4816 #endif
|
|
|
4817
|
|
|
4818 Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4819 {
|
|
|
4820 m_event = {};
|
|
|
4821 return *this;
|
|
|
4822 }
|
|
|
4823
|
|
|
4824 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
|
|
|
4825 {
|
|
|
4826 return m_event;
|
|
|
4827 }
|
|
|
4828
|
|
|
4829 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4830 {
|
|
|
4831 return m_event != VK_NULL_HANDLE;
|
|
|
4832 }
|
|
|
4833
|
|
|
4834 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4835 {
|
|
|
4836 return m_event == VK_NULL_HANDLE;
|
|
|
4837 }
|
|
|
4838
|
|
|
4839 private:
|
|
|
4840 VkEvent m_event = {};
|
|
|
4841 };
|
|
|
4842
|
|
|
4843 template <>
|
|
|
4844 struct CppType<ObjectType, ObjectType::eEvent>
|
|
|
4845 {
|
|
|
4846 using Type = Event;
|
|
|
4847 };
|
|
|
4848
|
|
|
4849 template <>
|
|
|
4850 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eEvent>
|
|
|
4851 {
|
|
|
4852 using Type = Event;
|
|
|
4853 };
|
|
|
4854
|
|
|
4855 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4856 template <>
|
|
|
4857 struct CppType<VkEvent, VK_NULL_HANDLE>
|
|
|
4858 {
|
|
|
4859 using Type = Event;
|
|
|
4860 };
|
|
|
4861 #endif
|
|
|
4862
|
|
|
4863 template <>
|
|
|
4864 struct isVulkanHandleType<Event>
|
|
|
4865 {
|
|
|
4866 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4867 };
|
|
|
4868
|
|
|
4869 // wrapper class for handle VkAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureKHR.html
|
|
|
4870 class AccelerationStructureKHR
|
|
|
4871 {
|
|
|
4872 public:
|
|
|
4873 using CType = VkAccelerationStructureKHR;
|
|
|
4874 using NativeType = VkAccelerationStructureKHR;
|
|
|
4875
|
|
|
4876 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureKHR;
|
|
|
4877 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureKHR;
|
|
|
4878
|
|
|
4879 public:
|
|
|
4880 AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4881
|
|
|
4882 AccelerationStructureKHR( AccelerationStructureKHR const & rhs ) = default;
|
|
|
4883 AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default;
|
|
|
4884
|
|
|
4885 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4886 AccelerationStructureKHR( AccelerationStructureKHR && rhs ) = default;
|
|
|
4887 AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default;
|
|
|
4888 #else
|
|
|
4889 AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4890 : m_accelerationStructureKHR( exchange( rhs.m_accelerationStructureKHR, {} ) )
|
|
|
4891 {
|
|
|
4892 }
|
|
|
4893
|
|
|
4894 AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4895 {
|
|
|
4896 m_accelerationStructureKHR = exchange( rhs.m_accelerationStructureKHR, {} );
|
|
|
4897 return *this;
|
|
|
4898 }
|
|
|
4899 #endif
|
|
|
4900
|
|
|
4901 VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4902
|
|
|
4903 VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
4904 : m_accelerationStructureKHR( accelerationStructureKHR )
|
|
|
4905 {
|
|
|
4906 }
|
|
|
4907
|
|
|
4908 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
4909 AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
4910 {
|
|
|
4911 m_accelerationStructureKHR = accelerationStructureKHR;
|
|
|
4912 return *this;
|
|
|
4913 }
|
|
|
4914 #endif
|
|
|
4915
|
|
|
4916 AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
4917 {
|
|
|
4918 m_accelerationStructureKHR = {};
|
|
|
4919 return *this;
|
|
|
4920 }
|
|
|
4921
|
|
|
4922 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
4923 {
|
|
|
4924 return m_accelerationStructureKHR;
|
|
|
4925 }
|
|
|
4926
|
|
|
4927 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
4928 {
|
|
|
4929 return m_accelerationStructureKHR != VK_NULL_HANDLE;
|
|
|
4930 }
|
|
|
4931
|
|
|
4932 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
4933 {
|
|
|
4934 return m_accelerationStructureKHR == VK_NULL_HANDLE;
|
|
|
4935 }
|
|
|
4936
|
|
|
4937 private:
|
|
|
4938 VkAccelerationStructureKHR m_accelerationStructureKHR = {};
|
|
|
4939 };
|
|
|
4940
|
|
|
4941 template <>
|
|
|
4942 struct CppType<ObjectType, ObjectType::eAccelerationStructureKHR>
|
|
|
4943 {
|
|
|
4944 using Type = AccelerationStructureKHR;
|
|
|
4945 };
|
|
|
4946
|
|
|
4947 template <>
|
|
|
4948 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eAccelerationStructureKHR>
|
|
|
4949 {
|
|
|
4950 using Type = AccelerationStructureKHR;
|
|
|
4951 };
|
|
|
4952
|
|
|
4953 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
4954 template <>
|
|
|
4955 struct CppType<VkAccelerationStructureKHR, VK_NULL_HANDLE>
|
|
|
4956 {
|
|
|
4957 using Type = AccelerationStructureKHR;
|
|
|
4958 };
|
|
|
4959 #endif
|
|
|
4960
|
|
|
4961 template <>
|
|
|
4962 struct isVulkanHandleType<AccelerationStructureKHR>
|
|
|
4963 {
|
|
|
4964 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
4965 };
|
|
|
4966
|
|
|
4967 // wrapper class for handle VkMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapEXT.html
|
|
|
4968 class MicromapEXT
|
|
|
4969 {
|
|
|
4970 public:
|
|
|
4971 using CType = VkMicromapEXT;
|
|
|
4972 using NativeType = VkMicromapEXT;
|
|
|
4973
|
|
|
4974 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eMicromapEXT;
|
|
|
4975 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
4976
|
|
|
4977 public:
|
|
|
4978 MicromapEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
4979
|
|
|
4980 MicromapEXT( MicromapEXT const & rhs ) = default;
|
|
|
4981 MicromapEXT & operator=( MicromapEXT const & rhs ) = default;
|
|
|
4982
|
|
|
4983 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
4984 MicromapEXT( MicromapEXT && rhs ) = default;
|
|
|
4985 MicromapEXT & operator=( MicromapEXT && rhs ) = default;
|
|
|
4986 #else
|
|
|
4987 MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( exchange( rhs.m_micromapEXT, {} ) ) {}
|
|
|
4988
|
|
|
4989 MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
4990 {
|
|
|
4991 m_micromapEXT = exchange( rhs.m_micromapEXT, {} );
|
|
|
4992 return *this;
|
|
|
4993 }
|
|
|
4994 #endif
|
|
|
4995
|
|
|
4996 VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
4997
|
|
|
4998 VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
|
|
|
4999
|
|
|
5000 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
5001 MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
5002 {
|
|
|
5003 m_micromapEXT = micromapEXT;
|
|
|
5004 return *this;
|
|
|
5005 }
|
|
|
5006 #endif
|
|
|
5007
|
|
|
5008 MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
5009 {
|
|
|
5010 m_micromapEXT = {};
|
|
|
5011 return *this;
|
|
|
5012 }
|
|
|
5013
|
|
|
5014 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
|
|
|
5015 {
|
|
|
5016 return m_micromapEXT;
|
|
|
5017 }
|
|
|
5018
|
|
|
5019 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
5020 {
|
|
|
5021 return m_micromapEXT != VK_NULL_HANDLE;
|
|
|
5022 }
|
|
|
5023
|
|
|
5024 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
5025 {
|
|
|
5026 return m_micromapEXT == VK_NULL_HANDLE;
|
|
|
5027 }
|
|
|
5028
|
|
|
5029 private:
|
|
|
5030 VkMicromapEXT m_micromapEXT = {};
|
|
|
5031 };
|
|
|
5032
|
|
|
5033 template <>
|
|
|
5034 struct CppType<ObjectType, ObjectType::eMicromapEXT>
|
|
|
5035 {
|
|
|
5036 using Type = MicromapEXT;
|
|
|
5037 };
|
|
|
5038
|
|
|
5039 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
5040 template <>
|
|
|
5041 struct CppType<VkMicromapEXT, VK_NULL_HANDLE>
|
|
|
5042 {
|
|
|
5043 using Type = MicromapEXT;
|
|
|
5044 };
|
|
|
5045 #endif
|
|
|
5046
|
|
|
5047 template <>
|
|
|
5048 struct isVulkanHandleType<MicromapEXT>
|
|
|
5049 {
|
|
|
5050 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
5051 };
|
|
|
5052
|
|
|
5053 // wrapper class for handle VkCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBuffer.html
|
|
|
5054 class CommandBuffer
|
|
|
5055 {
|
|
|
5056 public:
|
|
|
5057 using CType = VkCommandBuffer;
|
|
|
5058 using NativeType = VkCommandBuffer;
|
|
|
5059
|
|
|
5060 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer;
|
|
|
5061 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandBuffer;
|
|
|
5062
|
|
|
5063 public:
|
|
|
5064 CommandBuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
5065
|
|
|
5066 CommandBuffer( CommandBuffer const & rhs ) = default;
|
|
|
5067 CommandBuffer & operator=( CommandBuffer const & rhs ) = default;
|
|
|
5068
|
|
|
5069 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
5070 CommandBuffer( CommandBuffer && rhs ) = default;
|
|
|
5071 CommandBuffer & operator=( CommandBuffer && rhs ) = default;
|
|
|
5072 #else
|
|
|
5073 CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( exchange( rhs.m_commandBuffer, {} ) ) {}
|
|
|
5074
|
|
|
5075 CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
5076 {
|
|
|
5077 m_commandBuffer = exchange( rhs.m_commandBuffer, {} );
|
|
|
5078 return *this;
|
|
|
5079 }
|
|
|
5080 #endif
|
|
|
5081
|
|
|
5082 VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
5083
|
|
|
5084 CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
|
|
|
5085
|
|
|
5086 CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
|
|
|
5087 {
|
|
|
5088 m_commandBuffer = commandBuffer;
|
|
|
5089 return *this;
|
|
|
5090 }
|
|
|
5091
|
|
|
5092 CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
5093 {
|
|
|
5094 m_commandBuffer = {};
|
|
|
5095 return *this;
|
|
|
5096 }
|
|
|
5097
|
|
|
5098 //=== VK_VERSION_1_0 ===
|
|
|
5099
|
|
|
5100 // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html
|
|
|
5101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5102 VULKAN_HPP_NODISCARD Result begin( const CommandBufferBeginInfo * pBeginInfo,
|
|
|
5103 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5104 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5105 // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html
|
|
|
5106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5107 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo,
|
|
|
5108 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
5109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5110
|
|
|
5111 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5112 // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html
|
|
|
5113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5114 VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5115 #else
|
|
|
5116 // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html
|
|
|
5117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5118 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
5119 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
5120
|
|
|
5121 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5122 // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
|
|
|
5123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5124 VULKAN_HPP_NODISCARD Result reset( CommandBufferResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5125 #else
|
|
|
5126 // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
|
|
|
5127 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5128 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
5129 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
5130 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
5131
|
|
|
5132 // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html
|
|
|
5133 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5134 void copyBuffer( Buffer srcBuffer,
|
|
|
5135 Buffer dstBuffer,
|
|
|
5136 uint32_t regionCount,
|
|
|
5137 const BufferCopy * pRegions,
|
|
|
5138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5140 // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html
|
|
|
5141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5142 void copyBuffer( Buffer srcBuffer,
|
|
|
5143 Buffer dstBuffer,
|
|
|
5144 ArrayProxy<const BufferCopy> const & regions,
|
|
|
5145 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5147
|
|
|
5148 // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html
|
|
|
5149 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5150 void copyImage( Image srcImage,
|
|
|
5151 ImageLayout srcImageLayout,
|
|
|
5152 Image dstImage,
|
|
|
5153 ImageLayout dstImageLayout,
|
|
|
5154 uint32_t regionCount,
|
|
|
5155 const ImageCopy * pRegions,
|
|
|
5156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5158 // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html
|
|
|
5159 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5160 void copyImage( Image srcImage,
|
|
|
5161 ImageLayout srcImageLayout,
|
|
|
5162 Image dstImage,
|
|
|
5163 ImageLayout dstImageLayout,
|
|
|
5164 ArrayProxy<const ImageCopy> const & regions,
|
|
|
5165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5166 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5167
|
|
|
5168 // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html
|
|
|
5169 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5170 void copyBufferToImage( Buffer srcBuffer,
|
|
|
5171 Image dstImage,
|
|
|
5172 ImageLayout dstImageLayout,
|
|
|
5173 uint32_t regionCount,
|
|
|
5174 const BufferImageCopy * pRegions,
|
|
|
5175 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5176 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5177 // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html
|
|
|
5178 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5179 void copyBufferToImage( Buffer srcBuffer,
|
|
|
5180 Image dstImage,
|
|
|
5181 ImageLayout dstImageLayout,
|
|
|
5182 ArrayProxy<const BufferImageCopy> const & regions,
|
|
|
5183 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5185
|
|
|
5186 // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html
|
|
|
5187 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5188 void copyImageToBuffer( Image srcImage,
|
|
|
5189 ImageLayout srcImageLayout,
|
|
|
5190 Buffer dstBuffer,
|
|
|
5191 uint32_t regionCount,
|
|
|
5192 const BufferImageCopy * pRegions,
|
|
|
5193 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5195 // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html
|
|
|
5196 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5197 void copyImageToBuffer( Image srcImage,
|
|
|
5198 ImageLayout srcImageLayout,
|
|
|
5199 Buffer dstBuffer,
|
|
|
5200 ArrayProxy<const BufferImageCopy> const & regions,
|
|
|
5201 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5203
|
|
|
5204 // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html
|
|
|
5205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5206 void updateBuffer( Buffer dstBuffer,
|
|
|
5207 DeviceSize dstOffset,
|
|
|
5208 DeviceSize dataSize,
|
|
|
5209 const void * pData,
|
|
|
5210 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5212 // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html
|
|
|
5213 template <typename DataType,
|
|
|
5214 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
5215 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5216 void updateBuffer( Buffer dstBuffer,
|
|
|
5217 DeviceSize dstOffset,
|
|
|
5218 ArrayProxy<const DataType> const & data,
|
|
|
5219 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5220 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5221
|
|
|
5222 // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html
|
|
|
5223 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5224 void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
|
|
|
5225 VULKAN_HPP_NOEXCEPT;
|
|
|
5226
|
|
|
5227 // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html
|
|
|
5228 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5229 void pipelineBarrier( PipelineStageFlags srcStageMask,
|
|
|
5230 PipelineStageFlags dstStageMask,
|
|
|
5231 DependencyFlags dependencyFlags,
|
|
|
5232 uint32_t memoryBarrierCount,
|
|
|
5233 const MemoryBarrier * pMemoryBarriers,
|
|
|
5234 uint32_t bufferMemoryBarrierCount,
|
|
|
5235 const BufferMemoryBarrier * pBufferMemoryBarriers,
|
|
|
5236 uint32_t imageMemoryBarrierCount,
|
|
|
5237 const ImageMemoryBarrier * pImageMemoryBarriers,
|
|
|
5238 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5240 // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html
|
|
|
5241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5242 void pipelineBarrier( PipelineStageFlags srcStageMask,
|
|
|
5243 PipelineStageFlags dstStageMask,
|
|
|
5244 DependencyFlags dependencyFlags,
|
|
|
5245 ArrayProxy<const MemoryBarrier> const & memoryBarriers,
|
|
|
5246 ArrayProxy<const BufferMemoryBarrier> const & bufferMemoryBarriers,
|
|
|
5247 ArrayProxy<const ImageMemoryBarrier> const & imageMemoryBarriers,
|
|
|
5248 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5249 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5250
|
|
|
5251 // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html
|
|
|
5252 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5253 void beginQuery( QueryPool queryPool,
|
|
|
5254 uint32_t query,
|
|
|
5255 QueryControlFlags flags,
|
|
|
5256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5257
|
|
|
5258 // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html
|
|
|
5259 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5260 void endQuery( QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5261
|
|
|
5262 // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html
|
|
|
5263 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5264 void resetQueryPool( QueryPool queryPool,
|
|
|
5265 uint32_t firstQuery,
|
|
|
5266 uint32_t queryCount,
|
|
|
5267 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5268
|
|
|
5269 // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html
|
|
|
5270 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5271 void writeTimestamp( PipelineStageFlagBits pipelineStage,
|
|
|
5272 QueryPool queryPool,
|
|
|
5273 uint32_t query,
|
|
|
5274 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5275
|
|
|
5276 // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html
|
|
|
5277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5278 void copyQueryPoolResults( QueryPool queryPool,
|
|
|
5279 uint32_t firstQuery,
|
|
|
5280 uint32_t queryCount,
|
|
|
5281 Buffer dstBuffer,
|
|
|
5282 DeviceSize dstOffset,
|
|
|
5283 DeviceSize stride,
|
|
|
5284 QueryResultFlags flags,
|
|
|
5285 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5286
|
|
|
5287 // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html
|
|
|
5288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5289 void executeCommands( uint32_t commandBufferCount,
|
|
|
5290 const CommandBuffer * pCommandBuffers,
|
|
|
5291 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5292 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5293 // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html
|
|
|
5294 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5295 void executeCommands( ArrayProxy<const CommandBuffer> const & commandBuffers,
|
|
|
5296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5297 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5298
|
|
|
5299 // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html
|
|
|
5300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5301 void bindPipeline( PipelineBindPoint pipelineBindPoint,
|
|
|
5302 Pipeline pipeline,
|
|
|
5303 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5304
|
|
|
5305 // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html
|
|
|
5306 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5307 void bindDescriptorSets( PipelineBindPoint pipelineBindPoint,
|
|
|
5308 PipelineLayout layout,
|
|
|
5309 uint32_t firstSet,
|
|
|
5310 uint32_t descriptorSetCount,
|
|
|
5311 const DescriptorSet * pDescriptorSets,
|
|
|
5312 uint32_t dynamicOffsetCount,
|
|
|
5313 const uint32_t * pDynamicOffsets,
|
|
|
5314 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5315 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5316 // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html
|
|
|
5317 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5318 void bindDescriptorSets( PipelineBindPoint pipelineBindPoint,
|
|
|
5319 PipelineLayout layout,
|
|
|
5320 uint32_t firstSet,
|
|
|
5321 ArrayProxy<const DescriptorSet> const & descriptorSets,
|
|
|
5322 ArrayProxy<const uint32_t> const & dynamicOffsets,
|
|
|
5323 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5324 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5325
|
|
|
5326 // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html
|
|
|
5327 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5328 void clearColorImage( Image image,
|
|
|
5329 ImageLayout imageLayout,
|
|
|
5330 const ClearColorValue * pColor,
|
|
|
5331 uint32_t rangeCount,
|
|
|
5332 const ImageSubresourceRange * pRanges,
|
|
|
5333 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5335 // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html
|
|
|
5336 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5337 void clearColorImage( Image image,
|
|
|
5338 ImageLayout imageLayout,
|
|
|
5339 const ClearColorValue & color,
|
|
|
5340 ArrayProxy<const ImageSubresourceRange> const & ranges,
|
|
|
5341 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5343
|
|
|
5344 // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html
|
|
|
5345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5346 void dispatch( uint32_t groupCountX,
|
|
|
5347 uint32_t groupCountY,
|
|
|
5348 uint32_t groupCountZ,
|
|
|
5349 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5350
|
|
|
5351 // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html
|
|
|
5352 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5353 void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5354
|
|
|
5355 // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html
|
|
|
5356 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5357 void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5358
|
|
|
5359 // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html
|
|
|
5360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5361 void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5362
|
|
|
5363 // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html
|
|
|
5364 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5365 void waitEvents( uint32_t eventCount,
|
|
|
5366 const Event * pEvents,
|
|
|
5367 PipelineStageFlags srcStageMask,
|
|
|
5368 PipelineStageFlags dstStageMask,
|
|
|
5369 uint32_t memoryBarrierCount,
|
|
|
5370 const MemoryBarrier * pMemoryBarriers,
|
|
|
5371 uint32_t bufferMemoryBarrierCount,
|
|
|
5372 const BufferMemoryBarrier * pBufferMemoryBarriers,
|
|
|
5373 uint32_t imageMemoryBarrierCount,
|
|
|
5374 const ImageMemoryBarrier * pImageMemoryBarriers,
|
|
|
5375 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5377 // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html
|
|
|
5378 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5379 void waitEvents( ArrayProxy<const Event> const & events,
|
|
|
5380 PipelineStageFlags srcStageMask,
|
|
|
5381 PipelineStageFlags dstStageMask,
|
|
|
5382 ArrayProxy<const MemoryBarrier> const & memoryBarriers,
|
|
|
5383 ArrayProxy<const BufferMemoryBarrier> const & bufferMemoryBarriers,
|
|
|
5384 ArrayProxy<const ImageMemoryBarrier> const & imageMemoryBarriers,
|
|
|
5385 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5386 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5387
|
|
|
5388 // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html
|
|
|
5389 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5390 void pushConstants( PipelineLayout layout,
|
|
|
5391 ShaderStageFlags stageFlags,
|
|
|
5392 uint32_t offset,
|
|
|
5393 uint32_t size,
|
|
|
5394 const void * pValues,
|
|
|
5395 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5396 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5397 // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html
|
|
|
5398 template <typename ValuesType,
|
|
|
5399 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
5400 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5401 void pushConstants( PipelineLayout layout,
|
|
|
5402 ShaderStageFlags stageFlags,
|
|
|
5403 uint32_t offset,
|
|
|
5404 ArrayProxy<const ValuesType> const & values,
|
|
|
5405 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5406 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5407
|
|
|
5408 // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html
|
|
|
5409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5410 void setViewport( uint32_t firstViewport,
|
|
|
5411 uint32_t viewportCount,
|
|
|
5412 const Viewport * pViewports,
|
|
|
5413 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5415 // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html
|
|
|
5416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5417 void setViewport( uint32_t firstViewport,
|
|
|
5418 ArrayProxy<const Viewport> const & viewports,
|
|
|
5419 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5420 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5421
|
|
|
5422 // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html
|
|
|
5423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5424 void setScissor( uint32_t firstScissor,
|
|
|
5425 uint32_t scissorCount,
|
|
|
5426 const Rect2D * pScissors,
|
|
|
5427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5428 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5429 // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html
|
|
|
5430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5431 void setScissor( uint32_t firstScissor,
|
|
|
5432 ArrayProxy<const Rect2D> const & scissors,
|
|
|
5433 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5434 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5435
|
|
|
5436 // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html
|
|
|
5437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5438 void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5439
|
|
|
5440 // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html
|
|
|
5441 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5442 void setDepthBias( float depthBiasConstantFactor,
|
|
|
5443 float depthBiasClamp,
|
|
|
5444 float depthBiasSlopeFactor,
|
|
|
5445 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5446
|
|
|
5447 // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html
|
|
|
5448 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5449 void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5450
|
|
|
5451 // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html
|
|
|
5452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5453 void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5454
|
|
|
5455 // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html
|
|
|
5456 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5457 void setStencilCompareMask( StencilFaceFlags faceMask,
|
|
|
5458 uint32_t compareMask,
|
|
|
5459 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5460
|
|
|
5461 // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html
|
|
|
5462 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5463 void setStencilWriteMask( StencilFaceFlags faceMask,
|
|
|
5464 uint32_t writeMask,
|
|
|
5465 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5466
|
|
|
5467 // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html
|
|
|
5468 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5469 void setStencilReference( StencilFaceFlags faceMask,
|
|
|
5470 uint32_t reference,
|
|
|
5471 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5472
|
|
|
5473 // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html
|
|
|
5474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5475 void bindIndexBuffer( Buffer buffer,
|
|
|
5476 DeviceSize offset,
|
|
|
5477 IndexType indexType,
|
|
|
5478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5479
|
|
|
5480 // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html
|
|
|
5481 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5482 void bindVertexBuffers( uint32_t firstBinding,
|
|
|
5483 uint32_t bindingCount,
|
|
|
5484 const Buffer * pBuffers,
|
|
|
5485 const DeviceSize * pOffsets,
|
|
|
5486 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5488 // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html
|
|
|
5489 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5490 void bindVertexBuffers( uint32_t firstBinding,
|
|
|
5491 ArrayProxy<const Buffer> const & buffers,
|
|
|
5492 ArrayProxy<const DeviceSize> const & offsets,
|
|
|
5493 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
5494 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5495
|
|
|
5496 // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html
|
|
|
5497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5498 void draw( uint32_t vertexCount,
|
|
|
5499 uint32_t instanceCount,
|
|
|
5500 uint32_t firstVertex,
|
|
|
5501 uint32_t firstInstance,
|
|
|
5502 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5503
|
|
|
5504 // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html
|
|
|
5505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5506 void drawIndexed( uint32_t indexCount,
|
|
|
5507 uint32_t instanceCount,
|
|
|
5508 uint32_t firstIndex,
|
|
|
5509 int32_t vertexOffset,
|
|
|
5510 uint32_t firstInstance,
|
|
|
5511 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5512
|
|
|
5513 // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html
|
|
|
5514 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5515 void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
|
|
|
5516 const VULKAN_HPP_NOEXCEPT;
|
|
|
5517
|
|
|
5518 // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html
|
|
|
5519 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5520 void drawIndexedIndirect( Buffer buffer,
|
|
|
5521 DeviceSize offset,
|
|
|
5522 uint32_t drawCount,
|
|
|
5523 uint32_t stride,
|
|
|
5524 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5525
|
|
|
5526 // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html
|
|
|
5527 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5528 void blitImage( Image srcImage,
|
|
|
5529 ImageLayout srcImageLayout,
|
|
|
5530 Image dstImage,
|
|
|
5531 ImageLayout dstImageLayout,
|
|
|
5532 uint32_t regionCount,
|
|
|
5533 const ImageBlit * pRegions,
|
|
|
5534 Filter filter,
|
|
|
5535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5537 // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html
|
|
|
5538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5539 void blitImage( Image srcImage,
|
|
|
5540 ImageLayout srcImageLayout,
|
|
|
5541 Image dstImage,
|
|
|
5542 ImageLayout dstImageLayout,
|
|
|
5543 ArrayProxy<const ImageBlit> const & regions,
|
|
|
5544 Filter filter,
|
|
|
5545 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5546 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5547
|
|
|
5548 // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html
|
|
|
5549 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5550 void clearDepthStencilImage( Image image,
|
|
|
5551 ImageLayout imageLayout,
|
|
|
5552 const ClearDepthStencilValue * pDepthStencil,
|
|
|
5553 uint32_t rangeCount,
|
|
|
5554 const ImageSubresourceRange * pRanges,
|
|
|
5555 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5556 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5557 // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html
|
|
|
5558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5559 void clearDepthStencilImage( Image image,
|
|
|
5560 ImageLayout imageLayout,
|
|
|
5561 const ClearDepthStencilValue & depthStencil,
|
|
|
5562 ArrayProxy<const ImageSubresourceRange> const & ranges,
|
|
|
5563 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5564 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5565
|
|
|
5566 // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html
|
|
|
5567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5568 void clearAttachments( uint32_t attachmentCount,
|
|
|
5569 const ClearAttachment * pAttachments,
|
|
|
5570 uint32_t rectCount,
|
|
|
5571 const ClearRect * pRects,
|
|
|
5572 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5573 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5574 // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html
|
|
|
5575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5576 void clearAttachments( ArrayProxy<const ClearAttachment> const & attachments,
|
|
|
5577 ArrayProxy<const ClearRect> const & rects,
|
|
|
5578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5580
|
|
|
5581 // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html
|
|
|
5582 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5583 void resolveImage( Image srcImage,
|
|
|
5584 ImageLayout srcImageLayout,
|
|
|
5585 Image dstImage,
|
|
|
5586 ImageLayout dstImageLayout,
|
|
|
5587 uint32_t regionCount,
|
|
|
5588 const ImageResolve * pRegions,
|
|
|
5589 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5590 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5591 // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html
|
|
|
5592 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5593 void resolveImage( Image srcImage,
|
|
|
5594 ImageLayout srcImageLayout,
|
|
|
5595 Image dstImage,
|
|
|
5596 ImageLayout dstImageLayout,
|
|
|
5597 ArrayProxy<const ImageResolve> const & regions,
|
|
|
5598 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5599 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5600
|
|
|
5601 // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html
|
|
|
5602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5603 void beginRenderPass( const RenderPassBeginInfo * pRenderPassBegin,
|
|
|
5604 SubpassContents contents,
|
|
|
5605 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5606 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5607 // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html
|
|
|
5608 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5609 void beginRenderPass( const RenderPassBeginInfo & renderPassBegin,
|
|
|
5610 SubpassContents contents,
|
|
|
5611 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5612 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5613
|
|
|
5614 // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html
|
|
|
5615 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5616 void nextSubpass( SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5617
|
|
|
5618 // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html
|
|
|
5619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5620 void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5621
|
|
|
5622 //=== VK_VERSION_1_1 ===
|
|
|
5623
|
|
|
5624 // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html
|
|
|
5625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5626 void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5627
|
|
|
5628 // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html
|
|
|
5629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5630 void dispatchBase( uint32_t baseGroupX,
|
|
|
5631 uint32_t baseGroupY,
|
|
|
5632 uint32_t baseGroupZ,
|
|
|
5633 uint32_t groupCountX,
|
|
|
5634 uint32_t groupCountY,
|
|
|
5635 uint32_t groupCountZ,
|
|
|
5636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5637
|
|
|
5638 //=== VK_VERSION_1_2 ===
|
|
|
5639
|
|
|
5640 // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html
|
|
|
5641 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5642 void drawIndirectCount( Buffer buffer,
|
|
|
5643 DeviceSize offset,
|
|
|
5644 Buffer countBuffer,
|
|
|
5645 DeviceSize countBufferOffset,
|
|
|
5646 uint32_t maxDrawCount,
|
|
|
5647 uint32_t stride,
|
|
|
5648 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5649
|
|
|
5650 // wrapper function for command vkCmdDrawIndexedIndirectCount, see
|
|
|
5651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html
|
|
|
5652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5653 void drawIndexedIndirectCount( Buffer buffer,
|
|
|
5654 DeviceSize offset,
|
|
|
5655 Buffer countBuffer,
|
|
|
5656 DeviceSize countBufferOffset,
|
|
|
5657 uint32_t maxDrawCount,
|
|
|
5658 uint32_t stride,
|
|
|
5659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5660
|
|
|
5661 // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html
|
|
|
5662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5663 void beginRenderPass2( const RenderPassBeginInfo * pRenderPassBegin,
|
|
|
5664 const SubpassBeginInfo * pSubpassBeginInfo,
|
|
|
5665 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5667 // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html
|
|
|
5668 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5669 void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
|
|
|
5670 const SubpassBeginInfo & subpassBeginInfo,
|
|
|
5671 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5672 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5673
|
|
|
5674 // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html
|
|
|
5675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5676 void nextSubpass2( const SubpassBeginInfo * pSubpassBeginInfo,
|
|
|
5677 const SubpassEndInfo * pSubpassEndInfo,
|
|
|
5678 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5680 // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html
|
|
|
5681 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5682 void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
|
|
|
5683 const SubpassEndInfo & subpassEndInfo,
|
|
|
5684 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5685 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5686
|
|
|
5687 // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html
|
|
|
5688 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5689 void endRenderPass2( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5691 // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html
|
|
|
5692 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5693 void endRenderPass2( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5694 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5695
|
|
|
5696 //=== VK_VERSION_1_3 ===
|
|
|
5697
|
|
|
5698 // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html
|
|
|
5699 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5700 void pipelineBarrier2( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5702 // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html
|
|
|
5703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5704 void pipelineBarrier2( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5705 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5706
|
|
|
5707 // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html
|
|
|
5708 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5709 void writeTimestamp2( PipelineStageFlags2 stage,
|
|
|
5710 QueryPool queryPool,
|
|
|
5711 uint32_t query,
|
|
|
5712 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5713
|
|
|
5714 // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html
|
|
|
5715 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5716 void copyBuffer2( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5718 // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html
|
|
|
5719 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5720 void copyBuffer2( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5721 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5722
|
|
|
5723 // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html
|
|
|
5724 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5725 void copyImage2( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5727 // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html
|
|
|
5728 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5729 void copyImage2( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5731
|
|
|
5732 // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html
|
|
|
5733 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5734 void copyBufferToImage2( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
|
|
|
5735 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5736 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5737 // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html
|
|
|
5738 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5739 void copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo,
|
|
|
5740 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5741 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5742
|
|
|
5743 // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html
|
|
|
5744 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5745 void copyImageToBuffer2( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
|
|
|
5746 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5747 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5748 // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html
|
|
|
5749 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5750 void copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo,
|
|
|
5751 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5752 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5753
|
|
|
5754 // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html
|
|
|
5755 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5756 void
|
|
|
5757 setEvent2( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5759 // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html
|
|
|
5760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5761 void setEvent2( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5763
|
|
|
5764 // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html
|
|
|
5765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5766 void resetEvent2( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5767
|
|
|
5768 // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html
|
|
|
5769 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5770 void waitEvents2( uint32_t eventCount,
|
|
|
5771 const Event * pEvents,
|
|
|
5772 const DependencyInfo * pDependencyInfos,
|
|
|
5773 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5775 // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html
|
|
|
5776 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5777 void waitEvents2( ArrayProxy<const Event> const & events,
|
|
|
5778 ArrayProxy<const DependencyInfo> const & dependencyInfos,
|
|
|
5779 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
5780 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5781
|
|
|
5782 // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html
|
|
|
5783 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5784 void blitImage2( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5786 // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html
|
|
|
5787 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5788 void blitImage2( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5789 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5790
|
|
|
5791 // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html
|
|
|
5792 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5793 void resolveImage2( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5794 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5795 // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html
|
|
|
5796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5797 void resolveImage2( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5798 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5799
|
|
|
5800 // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html
|
|
|
5801 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5802 void beginRendering( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5803 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5804 // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html
|
|
|
5805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5806 void beginRendering( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5808
|
|
|
5809 // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html
|
|
|
5810 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5811 void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5812
|
|
|
5813 // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html
|
|
|
5814 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5815 void setCullMode( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5816
|
|
|
5817 // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html
|
|
|
5818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5819 void setFrontFace( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5820
|
|
|
5821 // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html
|
|
|
5822 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5823 void setPrimitiveTopology( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5824
|
|
|
5825 // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html
|
|
|
5826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5827 void setViewportWithCount( uint32_t viewportCount,
|
|
|
5828 const Viewport * pViewports,
|
|
|
5829 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5831 // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html
|
|
|
5832 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5833 void setViewportWithCount( ArrayProxy<const Viewport> const & viewports,
|
|
|
5834 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5835 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5836
|
|
|
5837 // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html
|
|
|
5838 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5839 void setScissorWithCount( uint32_t scissorCount,
|
|
|
5840 const Rect2D * pScissors,
|
|
|
5841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5843 // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html
|
|
|
5844 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5845 void setScissorWithCount( ArrayProxy<const Rect2D> const & scissors,
|
|
|
5846 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5847 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5848
|
|
|
5849 // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html
|
|
|
5850 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5851 void bindVertexBuffers2( uint32_t firstBinding,
|
|
|
5852 uint32_t bindingCount,
|
|
|
5853 const Buffer * pBuffers,
|
|
|
5854 const DeviceSize * pOffsets,
|
|
|
5855 const DeviceSize * pSizes,
|
|
|
5856 const DeviceSize * pStrides,
|
|
|
5857 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5859 // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html
|
|
|
5860 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5861 void bindVertexBuffers2( uint32_t firstBinding,
|
|
|
5862 ArrayProxy<const Buffer> const & buffers,
|
|
|
5863 ArrayProxy<const DeviceSize> const & offsets,
|
|
|
5864 ArrayProxy<const DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
5865 ArrayProxy<const DeviceSize> const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
5866 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
5867 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5868
|
|
|
5869 // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html
|
|
|
5870 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5871 void setDepthTestEnable( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5872
|
|
|
5873 // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html
|
|
|
5874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5875 void setDepthWriteEnable( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5876
|
|
|
5877 // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html
|
|
|
5878 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5879 void setDepthCompareOp( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5880
|
|
|
5881 // wrapper function for command vkCmdSetDepthBoundsTestEnable, see
|
|
|
5882 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html
|
|
|
5883 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5884 void setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5885
|
|
|
5886 // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html
|
|
|
5887 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5888 void setStencilTestEnable( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5889
|
|
|
5890 // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html
|
|
|
5891 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5892 void setStencilOp( StencilFaceFlags faceMask,
|
|
|
5893 StencilOp failOp,
|
|
|
5894 StencilOp passOp,
|
|
|
5895 StencilOp depthFailOp,
|
|
|
5896 CompareOp compareOp,
|
|
|
5897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5898
|
|
|
5899 // wrapper function for command vkCmdSetRasterizerDiscardEnable, see
|
|
|
5900 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html
|
|
|
5901 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5902 void setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5903
|
|
|
5904 // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html
|
|
|
5905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5906 void setDepthBiasEnable( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5907
|
|
|
5908 // wrapper function for command vkCmdSetPrimitiveRestartEnable, see
|
|
|
5909 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html
|
|
|
5910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5911 void setPrimitiveRestartEnable( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5912
|
|
|
5913 //=== VK_VERSION_1_4 ===
|
|
|
5914
|
|
|
5915 // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html
|
|
|
5916 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5917 void pushDescriptorSet( PipelineBindPoint pipelineBindPoint,
|
|
|
5918 PipelineLayout layout,
|
|
|
5919 uint32_t set,
|
|
|
5920 uint32_t descriptorWriteCount,
|
|
|
5921 const WriteDescriptorSet * pDescriptorWrites,
|
|
|
5922 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5923 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5924 // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html
|
|
|
5925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5926 void pushDescriptorSet( PipelineBindPoint pipelineBindPoint,
|
|
|
5927 PipelineLayout layout,
|
|
|
5928 uint32_t set,
|
|
|
5929 ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
|
|
|
5930 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5932
|
|
|
5933 // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see
|
|
|
5934 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html
|
|
|
5935 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5936 void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
5937 PipelineLayout layout,
|
|
|
5938 uint32_t set,
|
|
|
5939 const void * pData,
|
|
|
5940 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5941 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5942 // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see
|
|
|
5943 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html
|
|
|
5944 template <typename DataType,
|
|
|
5945 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
5946 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5947 void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
5948 PipelineLayout layout,
|
|
|
5949 uint32_t set,
|
|
|
5950 DataType const & data,
|
|
|
5951 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5952 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5953
|
|
|
5954 // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html
|
|
|
5955 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5956 void bindDescriptorSets2( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
|
|
|
5957 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5959 // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html
|
|
|
5960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5961 void bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo,
|
|
|
5962 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5964
|
|
|
5965 // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html
|
|
|
5966 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5967 void pushConstants2( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5968 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5969 // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html
|
|
|
5970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5971 void pushConstants2( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5972 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5973
|
|
|
5974 // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html
|
|
|
5975 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5976 void pushDescriptorSet2( const PushDescriptorSetInfo * pPushDescriptorSetInfo,
|
|
|
5977 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5978 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5979 // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html
|
|
|
5980 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5981 void pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo,
|
|
|
5982 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5983 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5984
|
|
|
5985 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see
|
|
|
5986 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html
|
|
|
5987 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5988 void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
|
|
|
5989 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5990 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
5991 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see
|
|
|
5992 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html
|
|
|
5993 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
5994 void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
|
|
|
5995 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
5996 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
5997
|
|
|
5998 // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html
|
|
|
5999 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6000 void setLineStipple( uint32_t lineStippleFactor,
|
|
|
6001 uint16_t lineStipplePattern,
|
|
|
6002 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6003
|
|
|
6004 // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html
|
|
|
6005 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6006 void bindIndexBuffer2( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
|
|
|
6007 const VULKAN_HPP_NOEXCEPT;
|
|
|
6008
|
|
|
6009 // wrapper function for command vkCmdSetRenderingAttachmentLocations, see
|
|
|
6010 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html
|
|
|
6011 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6012 void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo * pLocationInfo,
|
|
|
6013 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6014 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6015 // wrapper function for command vkCmdSetRenderingAttachmentLocations, see
|
|
|
6016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html
|
|
|
6017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6018 void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo,
|
|
|
6019 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6020 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6021
|
|
|
6022 // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see
|
|
|
6023 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html
|
|
|
6024 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6025 void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
|
|
|
6026 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6028 // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see
|
|
|
6029 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html
|
|
|
6030 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6031 void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
|
|
|
6032 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6033 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6034
|
|
|
6035 //=== VK_EXT_debug_marker ===
|
|
|
6036
|
|
|
6037 // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html
|
|
|
6038 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6039 void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo,
|
|
|
6040 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6041 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6042 // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html
|
|
|
6043 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6044 void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
|
|
|
6045 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6046 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6047
|
|
|
6048 // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html
|
|
|
6049 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6050 void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6051
|
|
|
6052 // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html
|
|
|
6053 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6054 void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo,
|
|
|
6055 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6057 // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html
|
|
|
6058 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6059 void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
|
|
|
6060 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6061 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6062
|
|
|
6063 //=== VK_KHR_video_queue ===
|
|
|
6064
|
|
|
6065 // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html
|
|
|
6066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6067 void beginVideoCodingKHR( const VideoBeginCodingInfoKHR * pBeginInfo,
|
|
|
6068 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6069 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6070 // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html
|
|
|
6071 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6072 void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
|
|
|
6073 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6074 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6075
|
|
|
6076 // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html
|
|
|
6077 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6078 void endVideoCodingKHR( const VideoEndCodingInfoKHR * pEndCodingInfo,
|
|
|
6079 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6080 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6081 // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html
|
|
|
6082 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6083 void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
|
|
|
6084 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6086
|
|
|
6087 // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html
|
|
|
6088 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6089 void controlVideoCodingKHR( const VideoCodingControlInfoKHR * pCodingControlInfo,
|
|
|
6090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6092 // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html
|
|
|
6093 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6094 void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
|
|
|
6095 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6096 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6097
|
|
|
6098 //=== VK_KHR_video_decode_queue ===
|
|
|
6099
|
|
|
6100 // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html
|
|
|
6101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6102 void decodeVideoKHR( const VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6104 // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html
|
|
|
6105 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6106 void decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6107 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6108
|
|
|
6109 //=== VK_EXT_transform_feedback ===
|
|
|
6110
|
|
|
6111 // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see
|
|
|
6112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html
|
|
|
6113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6114 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
|
|
|
6115 uint32_t bindingCount,
|
|
|
6116 const Buffer * pBuffers,
|
|
|
6117 const DeviceSize * pOffsets,
|
|
|
6118 const DeviceSize * pSizes,
|
|
|
6119 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6120 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6121 // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see
|
|
|
6122 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html
|
|
|
6123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6124 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
|
|
|
6125 ArrayProxy<const Buffer> const & buffers,
|
|
|
6126 ArrayProxy<const DeviceSize> const & offsets,
|
|
|
6127 ArrayProxy<const DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
6128 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
6129 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6130
|
|
|
6131 // wrapper function for command vkCmdBeginTransformFeedbackEXT, see
|
|
|
6132 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html
|
|
|
6133 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6134 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
|
|
|
6135 uint32_t counterBufferCount,
|
|
|
6136 const Buffer * pCounterBuffers,
|
|
|
6137 const DeviceSize * pCounterBufferOffsets,
|
|
|
6138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6140 // wrapper function for command vkCmdBeginTransformFeedbackEXT, see
|
|
|
6141 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html
|
|
|
6142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6143 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
|
|
|
6144 ArrayProxy<const Buffer> const & counterBuffers,
|
|
|
6145 ArrayProxy<const DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
6146 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
6147 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6148
|
|
|
6149 // wrapper function for command vkCmdEndTransformFeedbackEXT, see
|
|
|
6150 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html
|
|
|
6151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6152 void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
|
|
|
6153 uint32_t counterBufferCount,
|
|
|
6154 const Buffer * pCounterBuffers,
|
|
|
6155 const DeviceSize * pCounterBufferOffsets,
|
|
|
6156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6158 // wrapper function for command vkCmdEndTransformFeedbackEXT, see
|
|
|
6159 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html
|
|
|
6160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6161 void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
|
|
|
6162 ArrayProxy<const Buffer> const & counterBuffers,
|
|
|
6163 ArrayProxy<const DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
6164 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
6165 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6166
|
|
|
6167 // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html
|
|
|
6168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6169 void beginQueryIndexedEXT( QueryPool queryPool,
|
|
|
6170 uint32_t query,
|
|
|
6171 QueryControlFlags flags,
|
|
|
6172 uint32_t index,
|
|
|
6173 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6174
|
|
|
6175 // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html
|
|
|
6176 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6177 void endQueryIndexedEXT( QueryPool queryPool,
|
|
|
6178 uint32_t query,
|
|
|
6179 uint32_t index,
|
|
|
6180 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6181
|
|
|
6182 // wrapper function for command vkCmdDrawIndirectByteCountEXT, see
|
|
|
6183 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html
|
|
|
6184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6185 void drawIndirectByteCountEXT( uint32_t instanceCount,
|
|
|
6186 uint32_t firstInstance,
|
|
|
6187 Buffer counterBuffer,
|
|
|
6188 DeviceSize counterBufferOffset,
|
|
|
6189 uint32_t counterOffset,
|
|
|
6190 uint32_t vertexStride,
|
|
|
6191 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6192
|
|
|
6193 //=== VK_NVX_binary_import ===
|
|
|
6194
|
|
|
6195 // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html
|
|
|
6196 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6197 void cuLaunchKernelNVX( const CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6198 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6199 // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html
|
|
|
6200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6201 void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6203
|
|
|
6204 //=== VK_AMD_draw_indirect_count ===
|
|
|
6205
|
|
|
6206 // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html
|
|
|
6207 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6208 void drawIndirectCountAMD( Buffer buffer,
|
|
|
6209 DeviceSize offset,
|
|
|
6210 Buffer countBuffer,
|
|
|
6211 DeviceSize countBufferOffset,
|
|
|
6212 uint32_t maxDrawCount,
|
|
|
6213 uint32_t stride,
|
|
|
6214 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6215
|
|
|
6216 // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see
|
|
|
6217 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html
|
|
|
6218 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6219 void drawIndexedIndirectCountAMD( Buffer buffer,
|
|
|
6220 DeviceSize offset,
|
|
|
6221 Buffer countBuffer,
|
|
|
6222 DeviceSize countBufferOffset,
|
|
|
6223 uint32_t maxDrawCount,
|
|
|
6224 uint32_t stride,
|
|
|
6225 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6226
|
|
|
6227 //=== VK_KHR_dynamic_rendering ===
|
|
|
6228
|
|
|
6229 // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html
|
|
|
6230 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6231 void beginRenderingKHR( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6233 // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html
|
|
|
6234 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6235 void beginRenderingKHR( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6236 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6237
|
|
|
6238 // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html
|
|
|
6239 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6240 void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6241
|
|
|
6242 //=== VK_KHR_device_group ===
|
|
|
6243
|
|
|
6244 // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html
|
|
|
6245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6246 void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6247
|
|
|
6248 // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html
|
|
|
6249 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6250 void dispatchBaseKHR( uint32_t baseGroupX,
|
|
|
6251 uint32_t baseGroupY,
|
|
|
6252 uint32_t baseGroupZ,
|
|
|
6253 uint32_t groupCountX,
|
|
|
6254 uint32_t groupCountY,
|
|
|
6255 uint32_t groupCountZ,
|
|
|
6256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6257
|
|
|
6258 //=== VK_KHR_push_descriptor ===
|
|
|
6259
|
|
|
6260 // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html
|
|
|
6261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6262 void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint,
|
|
|
6263 PipelineLayout layout,
|
|
|
6264 uint32_t set,
|
|
|
6265 uint32_t descriptorWriteCount,
|
|
|
6266 const WriteDescriptorSet * pDescriptorWrites,
|
|
|
6267 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6269 // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html
|
|
|
6270 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6271 void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint,
|
|
|
6272 PipelineLayout layout,
|
|
|
6273 uint32_t set,
|
|
|
6274 ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
|
|
|
6275 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6276 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6277
|
|
|
6278 // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see
|
|
|
6279 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html
|
|
|
6280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6281 void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
6282 PipelineLayout layout,
|
|
|
6283 uint32_t set,
|
|
|
6284 const void * pData,
|
|
|
6285 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6286 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6287 // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see
|
|
|
6288 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html
|
|
|
6289 template <typename DataType,
|
|
|
6290 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
6291 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6292 void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
6293 PipelineLayout layout,
|
|
|
6294 uint32_t set,
|
|
|
6295 DataType const & data,
|
|
|
6296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6297 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6298
|
|
|
6299 //=== VK_EXT_conditional_rendering ===
|
|
|
6300
|
|
|
6301 // wrapper function for command vkCmdBeginConditionalRenderingEXT, see
|
|
|
6302 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html
|
|
|
6303 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6304 void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
|
|
|
6305 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6307 // wrapper function for command vkCmdBeginConditionalRenderingEXT, see
|
|
|
6308 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html
|
|
|
6309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6310 void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
|
|
|
6311 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6313
|
|
|
6314 // wrapper function for command vkCmdEndConditionalRenderingEXT, see
|
|
|
6315 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html
|
|
|
6316 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6317 void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6318
|
|
|
6319 //=== VK_NV_clip_space_w_scaling ===
|
|
|
6320
|
|
|
6321 // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html
|
|
|
6322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6323 void setViewportWScalingNV( uint32_t firstViewport,
|
|
|
6324 uint32_t viewportCount,
|
|
|
6325 const ViewportWScalingNV * pViewportWScalings,
|
|
|
6326 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6328 // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html
|
|
|
6329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6330 void setViewportWScalingNV( uint32_t firstViewport,
|
|
|
6331 ArrayProxy<const ViewportWScalingNV> const & viewportWScalings,
|
|
|
6332 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6334
|
|
|
6335 //=== VK_EXT_discard_rectangles ===
|
|
|
6336
|
|
|
6337 // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html
|
|
|
6338 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6339 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
|
|
|
6340 uint32_t discardRectangleCount,
|
|
|
6341 const Rect2D * pDiscardRectangles,
|
|
|
6342 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6344 // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html
|
|
|
6345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6346 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
|
|
|
6347 ArrayProxy<const Rect2D> const & discardRectangles,
|
|
|
6348 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6349 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6350
|
|
|
6351 // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see
|
|
|
6352 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html
|
|
|
6353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6354 void setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6355
|
|
|
6356 // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see
|
|
|
6357 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html
|
|
|
6358 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6359 void setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode,
|
|
|
6360 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6361
|
|
|
6362 //=== VK_KHR_create_renderpass2 ===
|
|
|
6363
|
|
|
6364 // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html
|
|
|
6365 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6366 void beginRenderPass2KHR( const RenderPassBeginInfo * pRenderPassBegin,
|
|
|
6367 const SubpassBeginInfo * pSubpassBeginInfo,
|
|
|
6368 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6370 // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html
|
|
|
6371 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6372 void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
|
|
|
6373 const SubpassBeginInfo & subpassBeginInfo,
|
|
|
6374 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6375 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6376
|
|
|
6377 // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html
|
|
|
6378 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6379 void nextSubpass2KHR( const SubpassBeginInfo * pSubpassBeginInfo,
|
|
|
6380 const SubpassEndInfo * pSubpassEndInfo,
|
|
|
6381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6383 // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html
|
|
|
6384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6385 void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
|
|
|
6386 const SubpassEndInfo & subpassEndInfo,
|
|
|
6387 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6389
|
|
|
6390 // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html
|
|
|
6391 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6392 void endRenderPass2KHR( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6393 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6394 // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html
|
|
|
6395 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6396 void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6398
|
|
|
6399 //=== VK_EXT_debug_utils ===
|
|
|
6400
|
|
|
6401 // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see
|
|
|
6402 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html
|
|
|
6403 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6404 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
|
|
|
6405 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6406 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6407 // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see
|
|
|
6408 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html
|
|
|
6409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6410 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6411 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6412
|
|
|
6413 // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html
|
|
|
6414 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6415 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6416
|
|
|
6417 // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see
|
|
|
6418 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html
|
|
|
6419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6420 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
|
|
|
6421 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6422 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6423 // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see
|
|
|
6424 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html
|
|
|
6425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6426 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
|
|
|
6427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6428 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6429
|
|
|
6430 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
6431 //=== VK_AMDX_shader_enqueue ===
|
|
|
6432
|
|
|
6433 // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see
|
|
|
6434 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html
|
|
|
6435 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6436 void initializeGraphScratchMemoryAMDX( Pipeline executionGraph,
|
|
|
6437 DeviceAddress scratch,
|
|
|
6438 DeviceSize scratchSize,
|
|
|
6439 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6440
|
|
|
6441 // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html
|
|
|
6442 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6443 void dispatchGraphAMDX( DeviceAddress scratch,
|
|
|
6444 DeviceSize scratchSize,
|
|
|
6445 const DispatchGraphCountInfoAMDX * pCountInfo,
|
|
|
6446 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6447 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6448 // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html
|
|
|
6449 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6450 void dispatchGraphAMDX( DeviceAddress scratch,
|
|
|
6451 DeviceSize scratchSize,
|
|
|
6452 const DispatchGraphCountInfoAMDX & countInfo,
|
|
|
6453 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6454 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6455
|
|
|
6456 // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see
|
|
|
6457 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html
|
|
|
6458 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6459 void dispatchGraphIndirectAMDX( DeviceAddress scratch,
|
|
|
6460 DeviceSize scratchSize,
|
|
|
6461 const DispatchGraphCountInfoAMDX * pCountInfo,
|
|
|
6462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6463 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6464 // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see
|
|
|
6465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html
|
|
|
6466 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6467 void dispatchGraphIndirectAMDX( DeviceAddress scratch,
|
|
|
6468 DeviceSize scratchSize,
|
|
|
6469 const DispatchGraphCountInfoAMDX & countInfo,
|
|
|
6470 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6471 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6472
|
|
|
6473 // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see
|
|
|
6474 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html
|
|
|
6475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6476 void dispatchGraphIndirectCountAMDX( DeviceAddress scratch,
|
|
|
6477 DeviceSize scratchSize,
|
|
|
6478 DeviceAddress countInfo,
|
|
|
6479 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6480 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
6481
|
|
|
6482 //=== VK_EXT_sample_locations ===
|
|
|
6483
|
|
|
6484 // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
|
|
|
6485 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6486 void setSampleLocationsEXT( const SampleLocationsInfoEXT * pSampleLocationsInfo,
|
|
|
6487 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6488 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6489 // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
|
|
|
6490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6491 void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
|
|
|
6492 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6493 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6494
|
|
|
6495 //=== VK_KHR_acceleration_structure ===
|
|
|
6496
|
|
|
6497 // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see
|
|
|
6498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html
|
|
|
6499 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6500 void buildAccelerationStructuresKHR( uint32_t infoCount,
|
|
|
6501 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
|
|
|
6502 const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
|
|
|
6503 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6504 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6505 // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see
|
|
|
6506 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html
|
|
|
6507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6508 void buildAccelerationStructuresKHR( ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
|
|
|
6509 ArrayProxy<const AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
|
|
|
6510 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
6511 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6512
|
|
|
6513 // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see
|
|
|
6514 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html
|
|
|
6515 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6516 void buildAccelerationStructuresIndirectKHR( uint32_t infoCount,
|
|
|
6517 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
|
|
|
6518 const DeviceAddress * pIndirectDeviceAddresses,
|
|
|
6519 const uint32_t * pIndirectStrides,
|
|
|
6520 const uint32_t * const * ppMaxPrimitiveCounts,
|
|
|
6521 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6522 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6523 // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see
|
|
|
6524 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html
|
|
|
6525 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6526 void buildAccelerationStructuresIndirectKHR( ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
|
|
|
6527 ArrayProxy<const DeviceAddress> const & indirectDeviceAddresses,
|
|
|
6528 ArrayProxy<const uint32_t> const & indirectStrides,
|
|
|
6529 ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts,
|
|
|
6530 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
6531 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6532
|
|
|
6533 // wrapper function for command vkCmdCopyAccelerationStructureKHR, see
|
|
|
6534 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html
|
|
|
6535 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6536 void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR * pInfo,
|
|
|
6537 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6539 // wrapper function for command vkCmdCopyAccelerationStructureKHR, see
|
|
|
6540 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html
|
|
|
6541 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6542 void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
|
|
|
6543 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6544 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6545
|
|
|
6546 // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see
|
|
|
6547 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html
|
|
|
6548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6549 void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR * pInfo,
|
|
|
6550 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6551 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6552 // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see
|
|
|
6553 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html
|
|
|
6554 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6555 void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
|
|
|
6556 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6558
|
|
|
6559 // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see
|
|
|
6560 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html
|
|
|
6561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6562 void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR * pInfo,
|
|
|
6563 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6565 // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see
|
|
|
6566 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html
|
|
|
6567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6568 void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
|
|
|
6569 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6571
|
|
|
6572 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see
|
|
|
6573 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html
|
|
|
6574 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6575 void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
|
|
|
6576 const AccelerationStructureKHR * pAccelerationStructures,
|
|
|
6577 QueryType queryType,
|
|
|
6578 QueryPool queryPool,
|
|
|
6579 uint32_t firstQuery,
|
|
|
6580 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6581 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6582 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see
|
|
|
6583 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html
|
|
|
6584 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6585 void writeAccelerationStructuresPropertiesKHR( ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures,
|
|
|
6586 QueryType queryType,
|
|
|
6587 QueryPool queryPool,
|
|
|
6588 uint32_t firstQuery,
|
|
|
6589 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6590 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6591
|
|
|
6592 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
6593
|
|
|
6594 // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html
|
|
|
6595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6596 void traceRaysKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
|
|
|
6597 const StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
|
|
|
6598 const StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
|
|
|
6599 const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
|
|
|
6600 uint32_t width,
|
|
|
6601 uint32_t height,
|
|
|
6602 uint32_t depth,
|
|
|
6603 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6604 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6605 // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html
|
|
|
6606 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6607 void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
|
|
|
6608 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
|
|
|
6609 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
|
|
|
6610 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
|
|
|
6611 uint32_t width,
|
|
|
6612 uint32_t height,
|
|
|
6613 uint32_t depth,
|
|
|
6614 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6615 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6616
|
|
|
6617 // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html
|
|
|
6618 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6619 void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
|
|
|
6620 const StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
|
|
|
6621 const StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
|
|
|
6622 const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
|
|
|
6623 DeviceAddress indirectDeviceAddress,
|
|
|
6624 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6625 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6626 // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html
|
|
|
6627 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6628 void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
|
|
|
6629 const StridedDeviceAddressRegionKHR & missShaderBindingTable,
|
|
|
6630 const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
|
|
|
6631 const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
|
|
|
6632 DeviceAddress indirectDeviceAddress,
|
|
|
6633 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6634 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6635
|
|
|
6636 // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see
|
|
|
6637 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html
|
|
|
6638 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6639 void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6640
|
|
|
6641 //=== VK_NV_shading_rate_image ===
|
|
|
6642
|
|
|
6643 // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html
|
|
|
6644 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6645 void bindShadingRateImageNV( ImageView imageView,
|
|
|
6646 ImageLayout imageLayout,
|
|
|
6647 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6648
|
|
|
6649 // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see
|
|
|
6650 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html
|
|
|
6651 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6652 void setViewportShadingRatePaletteNV( uint32_t firstViewport,
|
|
|
6653 uint32_t viewportCount,
|
|
|
6654 const ShadingRatePaletteNV * pShadingRatePalettes,
|
|
|
6655 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6657 // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see
|
|
|
6658 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html
|
|
|
6659 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6660 void setViewportShadingRatePaletteNV( uint32_t firstViewport,
|
|
|
6661 ArrayProxy<const ShadingRatePaletteNV> const & shadingRatePalettes,
|
|
|
6662 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6663 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6664
|
|
|
6665 // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html
|
|
|
6666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6667 void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType,
|
|
|
6668 uint32_t customSampleOrderCount,
|
|
|
6669 const CoarseSampleOrderCustomNV * pCustomSampleOrders,
|
|
|
6670 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6672 // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html
|
|
|
6673 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6674 void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType,
|
|
|
6675 ArrayProxy<const CoarseSampleOrderCustomNV> const & customSampleOrders,
|
|
|
6676 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6677 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6678
|
|
|
6679 //=== VK_NV_ray_tracing ===
|
|
|
6680
|
|
|
6681 // wrapper function for command vkCmdBuildAccelerationStructureNV, see
|
|
|
6682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html
|
|
|
6683 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6684 void buildAccelerationStructureNV( const AccelerationStructureInfoNV * pInfo,
|
|
|
6685 Buffer instanceData,
|
|
|
6686 DeviceSize instanceOffset,
|
|
|
6687 Bool32 update,
|
|
|
6688 AccelerationStructureNV dst,
|
|
|
6689 AccelerationStructureNV src,
|
|
|
6690 Buffer scratch,
|
|
|
6691 DeviceSize scratchOffset,
|
|
|
6692 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6694 // wrapper function for command vkCmdBuildAccelerationStructureNV, see
|
|
|
6695 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html
|
|
|
6696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6697 void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info,
|
|
|
6698 Buffer instanceData,
|
|
|
6699 DeviceSize instanceOffset,
|
|
|
6700 Bool32 update,
|
|
|
6701 AccelerationStructureNV dst,
|
|
|
6702 AccelerationStructureNV src,
|
|
|
6703 Buffer scratch,
|
|
|
6704 DeviceSize scratchOffset,
|
|
|
6705 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6706 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6707
|
|
|
6708 // wrapper function for command vkCmdCopyAccelerationStructureNV, see
|
|
|
6709 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html
|
|
|
6710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6711 void copyAccelerationStructureNV( AccelerationStructureNV dst,
|
|
|
6712 AccelerationStructureNV src,
|
|
|
6713 CopyAccelerationStructureModeKHR mode,
|
|
|
6714 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6715
|
|
|
6716 // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html
|
|
|
6717 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6718 void traceRaysNV( Buffer raygenShaderBindingTableBuffer,
|
|
|
6719 DeviceSize raygenShaderBindingOffset,
|
|
|
6720 Buffer missShaderBindingTableBuffer,
|
|
|
6721 DeviceSize missShaderBindingOffset,
|
|
|
6722 DeviceSize missShaderBindingStride,
|
|
|
6723 Buffer hitShaderBindingTableBuffer,
|
|
|
6724 DeviceSize hitShaderBindingOffset,
|
|
|
6725 DeviceSize hitShaderBindingStride,
|
|
|
6726 Buffer callableShaderBindingTableBuffer,
|
|
|
6727 DeviceSize callableShaderBindingOffset,
|
|
|
6728 DeviceSize callableShaderBindingStride,
|
|
|
6729 uint32_t width,
|
|
|
6730 uint32_t height,
|
|
|
6731 uint32_t depth,
|
|
|
6732 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6733
|
|
|
6734 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see
|
|
|
6735 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html
|
|
|
6736 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6737 void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount,
|
|
|
6738 const AccelerationStructureNV * pAccelerationStructures,
|
|
|
6739 QueryType queryType,
|
|
|
6740 QueryPool queryPool,
|
|
|
6741 uint32_t firstQuery,
|
|
|
6742 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6744 // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see
|
|
|
6745 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html
|
|
|
6746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6747 void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> const & accelerationStructures,
|
|
|
6748 QueryType queryType,
|
|
|
6749 QueryPool queryPool,
|
|
|
6750 uint32_t firstQuery,
|
|
|
6751 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6752 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6753
|
|
|
6754 //=== VK_KHR_draw_indirect_count ===
|
|
|
6755
|
|
|
6756 // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html
|
|
|
6757 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6758 void drawIndirectCountKHR( Buffer buffer,
|
|
|
6759 DeviceSize offset,
|
|
|
6760 Buffer countBuffer,
|
|
|
6761 DeviceSize countBufferOffset,
|
|
|
6762 uint32_t maxDrawCount,
|
|
|
6763 uint32_t stride,
|
|
|
6764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6765
|
|
|
6766 // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see
|
|
|
6767 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html
|
|
|
6768 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6769 void drawIndexedIndirectCountKHR( Buffer buffer,
|
|
|
6770 DeviceSize offset,
|
|
|
6771 Buffer countBuffer,
|
|
|
6772 DeviceSize countBufferOffset,
|
|
|
6773 uint32_t maxDrawCount,
|
|
|
6774 uint32_t stride,
|
|
|
6775 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6776
|
|
|
6777 //=== VK_AMD_buffer_marker ===
|
|
|
6778
|
|
|
6779 // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html
|
|
|
6780 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6781 void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage,
|
|
|
6782 Buffer dstBuffer,
|
|
|
6783 DeviceSize dstOffset,
|
|
|
6784 uint32_t marker,
|
|
|
6785 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6786
|
|
|
6787 // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html
|
|
|
6788 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6789 void writeBufferMarker2AMD( PipelineStageFlags2 stage,
|
|
|
6790 Buffer dstBuffer,
|
|
|
6791 DeviceSize dstOffset,
|
|
|
6792 uint32_t marker,
|
|
|
6793 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6794
|
|
|
6795 //=== VK_NV_mesh_shader ===
|
|
|
6796
|
|
|
6797 // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html
|
|
|
6798 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6799 void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6800
|
|
|
6801 // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see
|
|
|
6802 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html
|
|
|
6803 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6804 void drawMeshTasksIndirectNV( Buffer buffer,
|
|
|
6805 DeviceSize offset,
|
|
|
6806 uint32_t drawCount,
|
|
|
6807 uint32_t stride,
|
|
|
6808 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6809
|
|
|
6810 // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see
|
|
|
6811 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html
|
|
|
6812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6813 void drawMeshTasksIndirectCountNV( Buffer buffer,
|
|
|
6814 DeviceSize offset,
|
|
|
6815 Buffer countBuffer,
|
|
|
6816 DeviceSize countBufferOffset,
|
|
|
6817 uint32_t maxDrawCount,
|
|
|
6818 uint32_t stride,
|
|
|
6819 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6820
|
|
|
6821 //=== VK_NV_scissor_exclusive ===
|
|
|
6822
|
|
|
6823 // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see
|
|
|
6824 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html
|
|
|
6825 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6826 void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
|
|
|
6827 uint32_t exclusiveScissorCount,
|
|
|
6828 const Bool32 * pExclusiveScissorEnables,
|
|
|
6829 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6831 // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see
|
|
|
6832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html
|
|
|
6833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6834 void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
|
|
|
6835 ArrayProxy<const Bool32> const & exclusiveScissorEnables,
|
|
|
6836 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6838
|
|
|
6839 // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html
|
|
|
6840 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6841 void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
|
|
|
6842 uint32_t exclusiveScissorCount,
|
|
|
6843 const Rect2D * pExclusiveScissors,
|
|
|
6844 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6845 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6846 // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html
|
|
|
6847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6848 void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
|
|
|
6849 ArrayProxy<const Rect2D> const & exclusiveScissors,
|
|
|
6850 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6852
|
|
|
6853 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
6854
|
|
|
6855 // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html
|
|
|
6856 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6857 void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6859 // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html
|
|
|
6860 template <typename CheckpointMarkerType,
|
|
|
6861 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
6862 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6863 void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
|
|
|
6864 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6865 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6866
|
|
|
6867 //=== VK_INTEL_performance_query ===
|
|
|
6868
|
|
|
6869 // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see
|
|
|
6870 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html
|
|
|
6871 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6872 VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL * pMarkerInfo,
|
|
|
6873 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6875 // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see
|
|
|
6876 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html
|
|
|
6877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6878 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
6879 setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
6880 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6881
|
|
|
6882 // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see
|
|
|
6883 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html
|
|
|
6884 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6885 VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
|
|
|
6886 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6888 // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see
|
|
|
6889 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html
|
|
|
6890 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6891 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
6892 setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
6893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6894
|
|
|
6895 // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see
|
|
|
6896 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html
|
|
|
6897 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6898 VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL * pOverrideInfo,
|
|
|
6899 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6900 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6901 // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see
|
|
|
6902 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html
|
|
|
6903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6904 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
6905 setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
6906 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6907
|
|
|
6908 //=== VK_KHR_fragment_shading_rate ===
|
|
|
6909
|
|
|
6910 // wrapper function for command vkCmdSetFragmentShadingRateKHR, see
|
|
|
6911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
|
|
|
6912 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6913 void setFragmentShadingRateKHR( const Extent2D * pFragmentSize,
|
|
|
6914 const FragmentShadingRateCombinerOpKHR combinerOps[2],
|
|
|
6915 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6916 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6917 // wrapper function for command vkCmdSetFragmentShadingRateKHR, see
|
|
|
6918 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
|
|
|
6919 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6920 void setFragmentShadingRateKHR( const Extent2D & fragmentSize,
|
|
|
6921 const FragmentShadingRateCombinerOpKHR combinerOps[2],
|
|
|
6922 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6923 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6924
|
|
|
6925 //=== VK_KHR_dynamic_rendering_local_read ===
|
|
|
6926
|
|
|
6927 // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see
|
|
|
6928 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html
|
|
|
6929 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6930 void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo * pLocationInfo,
|
|
|
6931 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6932 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6933 // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see
|
|
|
6934 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html
|
|
|
6935 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6936 void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo,
|
|
|
6937 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6938 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6939
|
|
|
6940 // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see
|
|
|
6941 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html
|
|
|
6942 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6943 void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
|
|
|
6944 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6946 // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see
|
|
|
6947 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html
|
|
|
6948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6949 void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
|
|
|
6950 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6951 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6952
|
|
|
6953 //=== VK_EXT_line_rasterization ===
|
|
|
6954
|
|
|
6955 // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html
|
|
|
6956 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6957 void setLineStippleEXT( uint32_t lineStippleFactor,
|
|
|
6958 uint16_t lineStipplePattern,
|
|
|
6959 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6960
|
|
|
6961 //=== VK_EXT_extended_dynamic_state ===
|
|
|
6962
|
|
|
6963 // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html
|
|
|
6964 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6965 void setCullModeEXT( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6966
|
|
|
6967 // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html
|
|
|
6968 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6969 void setFrontFaceEXT( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6970
|
|
|
6971 // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see
|
|
|
6972 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html
|
|
|
6973 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6974 void setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6975
|
|
|
6976 // wrapper function for command vkCmdSetViewportWithCountEXT, see
|
|
|
6977 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html
|
|
|
6978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6979 void setViewportWithCountEXT( uint32_t viewportCount,
|
|
|
6980 const Viewport * pViewports,
|
|
|
6981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6982 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6983 // wrapper function for command vkCmdSetViewportWithCountEXT, see
|
|
|
6984 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html
|
|
|
6985 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6986 void setViewportWithCountEXT( ArrayProxy<const Viewport> const & viewports,
|
|
|
6987 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
6989
|
|
|
6990 // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html
|
|
|
6991 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6992 void setScissorWithCountEXT( uint32_t scissorCount,
|
|
|
6993 const Rect2D * pScissors,
|
|
|
6994 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
6995 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
6996 // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html
|
|
|
6997 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
6998 void setScissorWithCountEXT( ArrayProxy<const Rect2D> const & scissors,
|
|
|
6999 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7001
|
|
|
7002 // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html
|
|
|
7003 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7004 void bindVertexBuffers2EXT( uint32_t firstBinding,
|
|
|
7005 uint32_t bindingCount,
|
|
|
7006 const Buffer * pBuffers,
|
|
|
7007 const DeviceSize * pOffsets,
|
|
|
7008 const DeviceSize * pSizes,
|
|
|
7009 const DeviceSize * pStrides,
|
|
|
7010 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7012 // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html
|
|
|
7013 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7014 void bindVertexBuffers2EXT( uint32_t firstBinding,
|
|
|
7015 ArrayProxy<const Buffer> const & buffers,
|
|
|
7016 ArrayProxy<const DeviceSize> const & offsets,
|
|
|
7017 ArrayProxy<const DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
7018 ArrayProxy<const DeviceSize> const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
7019 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
7020 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7021
|
|
|
7022 // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html
|
|
|
7023 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7024 void setDepthTestEnableEXT( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7025
|
|
|
7026 // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html
|
|
|
7027 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7028 void setDepthWriteEnableEXT( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7029
|
|
|
7030 // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html
|
|
|
7031 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7032 void setDepthCompareOpEXT( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7033
|
|
|
7034 // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see
|
|
|
7035 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html
|
|
|
7036 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7037 void setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7038
|
|
|
7039 // wrapper function for command vkCmdSetStencilTestEnableEXT, see
|
|
|
7040 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html
|
|
|
7041 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7042 void setStencilTestEnableEXT( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7043
|
|
|
7044 // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html
|
|
|
7045 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7046 void setStencilOpEXT( StencilFaceFlags faceMask,
|
|
|
7047 StencilOp failOp,
|
|
|
7048 StencilOp passOp,
|
|
|
7049 StencilOp depthFailOp,
|
|
|
7050 CompareOp compareOp,
|
|
|
7051 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7052
|
|
|
7053 //=== VK_NV_device_generated_commands ===
|
|
|
7054
|
|
|
7055 // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see
|
|
|
7056 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html
|
|
|
7057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7058 void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
|
|
|
7059 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7060 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7061 // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see
|
|
|
7062 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html
|
|
|
7063 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7064 void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
|
|
|
7065 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7067
|
|
|
7068 // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see
|
|
|
7069 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html
|
|
|
7070 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7071 void executeGeneratedCommandsNV( Bool32 isPreprocessed,
|
|
|
7072 const GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
|
|
|
7073 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7075 // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see
|
|
|
7076 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html
|
|
|
7077 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7078 void executeGeneratedCommandsNV( Bool32 isPreprocessed,
|
|
|
7079 const GeneratedCommandsInfoNV & generatedCommandsInfo,
|
|
|
7080 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7081 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7082
|
|
|
7083 // wrapper function for command vkCmdBindPipelineShaderGroupNV, see
|
|
|
7084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html
|
|
|
7085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7086 void bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint,
|
|
|
7087 Pipeline pipeline,
|
|
|
7088 uint32_t groupIndex,
|
|
|
7089 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7090
|
|
|
7091 //=== VK_EXT_depth_bias_control ===
|
|
|
7092
|
|
|
7093 // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html
|
|
|
7094 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7095 void setDepthBias2EXT( const DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7096 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7097 // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html
|
|
|
7098 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7099 void setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7101
|
|
|
7102 //=== VK_KHR_video_encode_queue ===
|
|
|
7103
|
|
|
7104 // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html
|
|
|
7105 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7106 void encodeVideoKHR( const VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7108 // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html
|
|
|
7109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7110 void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7111 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7112
|
|
|
7113 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
7114 //=== VK_NV_cuda_kernel_launch ===
|
|
|
7115
|
|
|
7116 // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html
|
|
|
7117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7118 void cudaLaunchKernelNV( const CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7119 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7120 // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html
|
|
|
7121 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7122 void cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7123 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7124 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
7125
|
|
|
7126 //=== VK_QCOM_tile_shading ===
|
|
|
7127
|
|
|
7128 // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
|
|
|
7129 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7130 void dispatchTileQCOM( const DispatchTileInfoQCOM * pDispatchTileInfo,
|
|
|
7131 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7133 // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
|
|
|
7134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7135 void dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo,
|
|
|
7136 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7137 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7138
|
|
|
7139 // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
|
|
|
7140 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
|
|
|
7141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7142 void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM * pPerTileBeginInfo,
|
|
|
7143 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7145 // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
|
|
|
7146 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
|
|
|
7147 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7148 void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo,
|
|
|
7149 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7150 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7151
|
|
|
7152 // wrapper function for command vkCmdEndPerTileExecutionQCOM, see
|
|
|
7153 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
|
|
|
7154 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7155 void endPerTileExecutionQCOM( const PerTileEndInfoQCOM * pPerTileEndInfo,
|
|
|
7156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7158 // wrapper function for command vkCmdEndPerTileExecutionQCOM, see
|
|
|
7159 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
|
|
|
7160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7161 void endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo,
|
|
|
7162 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7164
|
|
|
7165 //=== VK_KHR_synchronization2 ===
|
|
|
7166
|
|
|
7167 // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html
|
|
|
7168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7169 void setEvent2KHR( Event event,
|
|
|
7170 const DependencyInfo * pDependencyInfo,
|
|
|
7171 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7173 // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html
|
|
|
7174 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7175 void
|
|
|
7176 setEvent2KHR( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7177 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7178
|
|
|
7179 // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html
|
|
|
7180 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7181 void resetEvent2KHR( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7182
|
|
|
7183 // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html
|
|
|
7184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7185 void waitEvents2KHR( uint32_t eventCount,
|
|
|
7186 const Event * pEvents,
|
|
|
7187 const DependencyInfo * pDependencyInfos,
|
|
|
7188 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7189 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7190 // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html
|
|
|
7191 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7192 void waitEvents2KHR( ArrayProxy<const Event> const & events,
|
|
|
7193 ArrayProxy<const DependencyInfo> const & dependencyInfos,
|
|
|
7194 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
7195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7196
|
|
|
7197 // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html
|
|
|
7198 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7199 void pipelineBarrier2KHR( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7200 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7201 // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html
|
|
|
7202 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7203 void pipelineBarrier2KHR( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7204 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7205
|
|
|
7206 // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html
|
|
|
7207 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7208 void writeTimestamp2KHR( PipelineStageFlags2 stage,
|
|
|
7209 QueryPool queryPool,
|
|
|
7210 uint32_t query,
|
|
|
7211 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7212
|
|
|
7213 //=== VK_EXT_descriptor_buffer ===
|
|
|
7214
|
|
|
7215 // wrapper function for command vkCmdBindDescriptorBuffersEXT, see
|
|
|
7216 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html
|
|
|
7217 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7218 void bindDescriptorBuffersEXT( uint32_t bufferCount,
|
|
|
7219 const DescriptorBufferBindingInfoEXT * pBindingInfos,
|
|
|
7220 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7221 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7222 // wrapper function for command vkCmdBindDescriptorBuffersEXT, see
|
|
|
7223 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html
|
|
|
7224 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7225 void bindDescriptorBuffersEXT( ArrayProxy<const DescriptorBufferBindingInfoEXT> const & bindingInfos,
|
|
|
7226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7228
|
|
|
7229 // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see
|
|
|
7230 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html
|
|
|
7231 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7232 void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint,
|
|
|
7233 PipelineLayout layout,
|
|
|
7234 uint32_t firstSet,
|
|
|
7235 uint32_t setCount,
|
|
|
7236 const uint32_t * pBufferIndices,
|
|
|
7237 const DeviceSize * pOffsets,
|
|
|
7238 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7240 // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see
|
|
|
7241 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html
|
|
|
7242 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7243 void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint,
|
|
|
7244 PipelineLayout layout,
|
|
|
7245 uint32_t firstSet,
|
|
|
7246 ArrayProxy<const uint32_t> const & bufferIndices,
|
|
|
7247 ArrayProxy<const DeviceSize> const & offsets,
|
|
|
7248 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
7249 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7250
|
|
|
7251 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see
|
|
|
7252 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html
|
|
|
7253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7254 void bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint,
|
|
|
7255 PipelineLayout layout,
|
|
|
7256 uint32_t set,
|
|
|
7257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7258
|
|
|
7259 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
7260
|
|
|
7261 // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see
|
|
|
7262 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html
|
|
|
7263 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7264 void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate,
|
|
|
7265 const FragmentShadingRateCombinerOpKHR combinerOps[2],
|
|
|
7266 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7267
|
|
|
7268 //=== VK_EXT_mesh_shader ===
|
|
|
7269
|
|
|
7270 // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html
|
|
|
7271 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7272 void drawMeshTasksEXT( uint32_t groupCountX,
|
|
|
7273 uint32_t groupCountY,
|
|
|
7274 uint32_t groupCountZ,
|
|
|
7275 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7276
|
|
|
7277 // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see
|
|
|
7278 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html
|
|
|
7279 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7280 void drawMeshTasksIndirectEXT( Buffer buffer,
|
|
|
7281 DeviceSize offset,
|
|
|
7282 uint32_t drawCount,
|
|
|
7283 uint32_t stride,
|
|
|
7284 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7285
|
|
|
7286 // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see
|
|
|
7287 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html
|
|
|
7288 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7289 void drawMeshTasksIndirectCountEXT( Buffer buffer,
|
|
|
7290 DeviceSize offset,
|
|
|
7291 Buffer countBuffer,
|
|
|
7292 DeviceSize countBufferOffset,
|
|
|
7293 uint32_t maxDrawCount,
|
|
|
7294 uint32_t stride,
|
|
|
7295 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7296
|
|
|
7297 //=== VK_KHR_copy_commands2 ===
|
|
|
7298
|
|
|
7299 // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html
|
|
|
7300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7301 void copyBuffer2KHR( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7302 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7303 // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html
|
|
|
7304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7305 void copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7307
|
|
|
7308 // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html
|
|
|
7309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7310 void copyImage2KHR( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7312 // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html
|
|
|
7313 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7314 void copyImage2KHR( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7315 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7316
|
|
|
7317 // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html
|
|
|
7318 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7319 void copyBufferToImage2KHR( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
|
|
|
7320 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7322 // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html
|
|
|
7323 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7324 void copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo,
|
|
|
7325 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7326 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7327
|
|
|
7328 // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html
|
|
|
7329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7330 void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
|
|
|
7331 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7333 // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html
|
|
|
7334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7335 void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo,
|
|
|
7336 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7337 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7338
|
|
|
7339 // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html
|
|
|
7340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7341 void blitImage2KHR( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7342 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7343 // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html
|
|
|
7344 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7345 void blitImage2KHR( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7346 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7347
|
|
|
7348 // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html
|
|
|
7349 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7350 void resolveImage2KHR( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7351 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7352 // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html
|
|
|
7353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7354 void resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7355 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7356
|
|
|
7357 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
7358
|
|
|
7359 // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html
|
|
|
7360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7361 void setVertexInputEXT( uint32_t vertexBindingDescriptionCount,
|
|
|
7362 const VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
|
|
|
7363 uint32_t vertexAttributeDescriptionCount,
|
|
|
7364 const VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
|
|
|
7365 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7367 // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html
|
|
|
7368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7369 void setVertexInputEXT( ArrayProxy<const VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
|
|
|
7370 ArrayProxy<const VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
|
|
|
7371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7373
|
|
|
7374 //=== VK_HUAWEI_subpass_shading ===
|
|
|
7375
|
|
|
7376 // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html
|
|
|
7377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7378 void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7379
|
|
|
7380 //=== VK_HUAWEI_invocation_mask ===
|
|
|
7381
|
|
|
7382 // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see
|
|
|
7383 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html
|
|
|
7384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7385 void bindInvocationMaskHUAWEI( ImageView imageView,
|
|
|
7386 ImageLayout imageLayout,
|
|
|
7387 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7388
|
|
|
7389 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
7390
|
|
|
7391 // wrapper function for command vkCmdSetPatchControlPointsEXT, see
|
|
|
7392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html
|
|
|
7393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7394 void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7395
|
|
|
7396 // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see
|
|
|
7397 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html
|
|
|
7398 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7399 void setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7400
|
|
|
7401 // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html
|
|
|
7402 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7403 void setDepthBiasEnableEXT( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7404
|
|
|
7405 // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html
|
|
|
7406 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7407 void setLogicOpEXT( LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7408
|
|
|
7409 // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see
|
|
|
7410 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html
|
|
|
7411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7412 void setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7413
|
|
|
7414 //=== VK_EXT_color_write_enable ===
|
|
|
7415
|
|
|
7416 // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html
|
|
|
7417 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7418 void setColorWriteEnableEXT( uint32_t attachmentCount,
|
|
|
7419 const Bool32 * pColorWriteEnables,
|
|
|
7420 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7422 // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html
|
|
|
7423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7424 void setColorWriteEnableEXT( ArrayProxy<const Bool32> const & colorWriteEnables,
|
|
|
7425 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7426 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7427
|
|
|
7428 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
7429
|
|
|
7430 // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html
|
|
|
7431 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7432 void traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7433
|
|
|
7434 //=== VK_EXT_multi_draw ===
|
|
|
7435
|
|
|
7436 // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html
|
|
|
7437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7438 void drawMultiEXT( uint32_t drawCount,
|
|
|
7439 const MultiDrawInfoEXT * pVertexInfo,
|
|
|
7440 uint32_t instanceCount,
|
|
|
7441 uint32_t firstInstance,
|
|
|
7442 uint32_t stride,
|
|
|
7443 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7444 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7445 // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html
|
|
|
7446 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7447 void drawMultiEXT( StridedArrayProxy<const MultiDrawInfoEXT> const & vertexInfo,
|
|
|
7448 uint32_t instanceCount,
|
|
|
7449 uint32_t firstInstance,
|
|
|
7450 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7451 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7452
|
|
|
7453 // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html
|
|
|
7454 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7455 void drawMultiIndexedEXT( uint32_t drawCount,
|
|
|
7456 const MultiDrawIndexedInfoEXT * pIndexInfo,
|
|
|
7457 uint32_t instanceCount,
|
|
|
7458 uint32_t firstInstance,
|
|
|
7459 uint32_t stride,
|
|
|
7460 const int32_t * pVertexOffset,
|
|
|
7461 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7463 // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html
|
|
|
7464 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7465 void drawMultiIndexedEXT( StridedArrayProxy<const MultiDrawIndexedInfoEXT> const & indexInfo,
|
|
|
7466 uint32_t instanceCount,
|
|
|
7467 uint32_t firstInstance,
|
|
|
7468 Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
7469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7470 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7471
|
|
|
7472 //=== VK_EXT_opacity_micromap ===
|
|
|
7473
|
|
|
7474 // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html
|
|
|
7475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7476 void buildMicromapsEXT( uint32_t infoCount,
|
|
|
7477 const MicromapBuildInfoEXT * pInfos,
|
|
|
7478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7480 // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html
|
|
|
7481 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7482 void buildMicromapsEXT( ArrayProxy<const MicromapBuildInfoEXT> const & infos,
|
|
|
7483 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7485
|
|
|
7486 // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html
|
|
|
7487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7488 void copyMicromapEXT( const CopyMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7490 // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html
|
|
|
7491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7492 void copyMicromapEXT( const CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7493 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7494
|
|
|
7495 // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see
|
|
|
7496 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html
|
|
|
7497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7498 void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT * pInfo,
|
|
|
7499 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7501 // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see
|
|
|
7502 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html
|
|
|
7503 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7504 void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info,
|
|
|
7505 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7506 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7507
|
|
|
7508 // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see
|
|
|
7509 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html
|
|
|
7510 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7511 void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT * pInfo,
|
|
|
7512 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7514 // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see
|
|
|
7515 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html
|
|
|
7516 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7517 void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info,
|
|
|
7518 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7519 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7520
|
|
|
7521 // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see
|
|
|
7522 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html
|
|
|
7523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7524 void writeMicromapsPropertiesEXT( uint32_t micromapCount,
|
|
|
7525 const MicromapEXT * pMicromaps,
|
|
|
7526 QueryType queryType,
|
|
|
7527 QueryPool queryPool,
|
|
|
7528 uint32_t firstQuery,
|
|
|
7529 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7531 // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see
|
|
|
7532 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html
|
|
|
7533 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7534 void writeMicromapsPropertiesEXT( ArrayProxy<const MicromapEXT> const & micromaps,
|
|
|
7535 QueryType queryType,
|
|
|
7536 QueryPool queryPool,
|
|
|
7537 uint32_t firstQuery,
|
|
|
7538 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7539 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7540
|
|
|
7541 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
7542
|
|
|
7543 // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html
|
|
|
7544 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7545 void drawClusterHUAWEI( uint32_t groupCountX,
|
|
|
7546 uint32_t groupCountY,
|
|
|
7547 uint32_t groupCountZ,
|
|
|
7548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7549
|
|
|
7550 // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see
|
|
|
7551 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html
|
|
|
7552 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7553 void drawClusterIndirectHUAWEI( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7554
|
|
|
7555 //=== VK_NV_copy_memory_indirect ===
|
|
|
7556
|
|
|
7557 // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html
|
|
|
7558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7559 void copyMemoryIndirectNV( DeviceAddress copyBufferAddress,
|
|
|
7560 uint32_t copyCount,
|
|
|
7561 uint32_t stride,
|
|
|
7562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7563
|
|
|
7564 // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see
|
|
|
7565 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html
|
|
|
7566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7567 void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress,
|
|
|
7568 uint32_t copyCount,
|
|
|
7569 uint32_t stride,
|
|
|
7570 Image dstImage,
|
|
|
7571 ImageLayout dstImageLayout,
|
|
|
7572 const ImageSubresourceLayers * pImageSubresources,
|
|
|
7573 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7575 // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see
|
|
|
7576 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html
|
|
|
7577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7578 void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress,
|
|
|
7579 uint32_t stride,
|
|
|
7580 Image dstImage,
|
|
|
7581 ImageLayout dstImageLayout,
|
|
|
7582 ArrayProxy<const ImageSubresourceLayers> const & imageSubresources,
|
|
|
7583 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7584 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7585
|
|
|
7586 //=== VK_NV_memory_decompression ===
|
|
|
7587
|
|
|
7588 // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html
|
|
|
7589 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7590 void decompressMemoryNV( uint32_t decompressRegionCount,
|
|
|
7591 const DecompressMemoryRegionNV * pDecompressMemoryRegions,
|
|
|
7592 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7593 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7594 // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html
|
|
|
7595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7596 void decompressMemoryNV( ArrayProxy<const DecompressMemoryRegionNV> const & decompressMemoryRegions,
|
|
|
7597 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7598 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7599
|
|
|
7600 // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see
|
|
|
7601 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html
|
|
|
7602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7603 void decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress,
|
|
|
7604 DeviceAddress indirectCommandsCountAddress,
|
|
|
7605 uint32_t stride,
|
|
|
7606 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7607
|
|
|
7608 //=== VK_NV_device_generated_commands_compute ===
|
|
|
7609
|
|
|
7610 // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see
|
|
|
7611 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html
|
|
|
7612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7613 void updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint,
|
|
|
7614 Pipeline pipeline,
|
|
|
7615 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7616
|
|
|
7617 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
7618
|
|
|
7619 // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html
|
|
|
7620 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7621 void setDepthClampEnableEXT( Bool32 depthClampEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7622
|
|
|
7623 // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html
|
|
|
7624 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7625 void setPolygonModeEXT( PolygonMode polygonMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7626
|
|
|
7627 // wrapper function for command vkCmdSetRasterizationSamplesEXT, see
|
|
|
7628 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html
|
|
|
7629 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7630 void setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples,
|
|
|
7631 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7632
|
|
|
7633 // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html
|
|
|
7634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7635 void setSampleMaskEXT( SampleCountFlagBits samples,
|
|
|
7636 const SampleMask * pSampleMask,
|
|
|
7637 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7639 // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html
|
|
|
7640 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7641 void setSampleMaskEXT( SampleCountFlagBits samples,
|
|
|
7642 ArrayProxy<const SampleMask> const & sampleMask VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
7643 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
7644 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7645
|
|
|
7646 // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see
|
|
|
7647 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html
|
|
|
7648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7649 void setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7650
|
|
|
7651 // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html
|
|
|
7652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7653 void setAlphaToOneEnableEXT( Bool32 alphaToOneEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7654
|
|
|
7655 // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html
|
|
|
7656 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7657 void setLogicOpEnableEXT( Bool32 logicOpEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7658
|
|
|
7659 // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html
|
|
|
7660 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7661 void setColorBlendEnableEXT( uint32_t firstAttachment,
|
|
|
7662 uint32_t attachmentCount,
|
|
|
7663 const Bool32 * pColorBlendEnables,
|
|
|
7664 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7666 // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html
|
|
|
7667 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7668 void setColorBlendEnableEXT( uint32_t firstAttachment,
|
|
|
7669 ArrayProxy<const Bool32> const & colorBlendEnables,
|
|
|
7670 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7672
|
|
|
7673 // wrapper function for command vkCmdSetColorBlendEquationEXT, see
|
|
|
7674 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html
|
|
|
7675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7676 void setColorBlendEquationEXT( uint32_t firstAttachment,
|
|
|
7677 uint32_t attachmentCount,
|
|
|
7678 const ColorBlendEquationEXT * pColorBlendEquations,
|
|
|
7679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7681 // wrapper function for command vkCmdSetColorBlendEquationEXT, see
|
|
|
7682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html
|
|
|
7683 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7684 void setColorBlendEquationEXT( uint32_t firstAttachment,
|
|
|
7685 ArrayProxy<const ColorBlendEquationEXT> const & colorBlendEquations,
|
|
|
7686 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7688
|
|
|
7689 // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html
|
|
|
7690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7691 void setColorWriteMaskEXT( uint32_t firstAttachment,
|
|
|
7692 uint32_t attachmentCount,
|
|
|
7693 const ColorComponentFlags * pColorWriteMasks,
|
|
|
7694 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7696 // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html
|
|
|
7697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7698 void setColorWriteMaskEXT( uint32_t firstAttachment,
|
|
|
7699 ArrayProxy<const ColorComponentFlags> const & colorWriteMasks,
|
|
|
7700 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7701 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7702
|
|
|
7703 // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see
|
|
|
7704 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html
|
|
|
7705 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7706 void setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin,
|
|
|
7707 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7708
|
|
|
7709 // wrapper function for command vkCmdSetRasterizationStreamEXT, see
|
|
|
7710 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html
|
|
|
7711 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7712 void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7713
|
|
|
7714 // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see
|
|
|
7715 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html
|
|
|
7716 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7717 void setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode,
|
|
|
7718 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7719
|
|
|
7720 // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see
|
|
|
7721 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html
|
|
|
7722 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7723 void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize,
|
|
|
7724 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7725
|
|
|
7726 // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html
|
|
|
7727 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7728 void setDepthClipEnableEXT( Bool32 depthClipEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7729
|
|
|
7730 // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see
|
|
|
7731 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html
|
|
|
7732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7733 void setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7734
|
|
|
7735 // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see
|
|
|
7736 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html
|
|
|
7737 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7738 void setColorBlendAdvancedEXT( uint32_t firstAttachment,
|
|
|
7739 uint32_t attachmentCount,
|
|
|
7740 const ColorBlendAdvancedEXT * pColorBlendAdvanced,
|
|
|
7741 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7742 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7743 // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see
|
|
|
7744 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html
|
|
|
7745 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7746 void setColorBlendAdvancedEXT( uint32_t firstAttachment,
|
|
|
7747 ArrayProxy<const ColorBlendAdvancedEXT> const & colorBlendAdvanced,
|
|
|
7748 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7749 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7750
|
|
|
7751 // wrapper function for command vkCmdSetProvokingVertexModeEXT, see
|
|
|
7752 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html
|
|
|
7753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7754 void setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode,
|
|
|
7755 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7756
|
|
|
7757 // wrapper function for command vkCmdSetLineRasterizationModeEXT, see
|
|
|
7758 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html
|
|
|
7759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7760 void setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode,
|
|
|
7761 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7762
|
|
|
7763 // wrapper function for command vkCmdSetLineStippleEnableEXT, see
|
|
|
7764 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html
|
|
|
7765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7766 void setLineStippleEnableEXT( Bool32 stippledLineEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7767
|
|
|
7768 // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see
|
|
|
7769 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html
|
|
|
7770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7771 void setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7772
|
|
|
7773 // wrapper function for command vkCmdSetViewportWScalingEnableNV, see
|
|
|
7774 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html
|
|
|
7775 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7776 void setViewportWScalingEnableNV( Bool32 viewportWScalingEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7777
|
|
|
7778 // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html
|
|
|
7779 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7780 void setViewportSwizzleNV( uint32_t firstViewport,
|
|
|
7781 uint32_t viewportCount,
|
|
|
7782 const ViewportSwizzleNV * pViewportSwizzles,
|
|
|
7783 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7784 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7785 // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html
|
|
|
7786 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7787 void setViewportSwizzleNV( uint32_t firstViewport,
|
|
|
7788 ArrayProxy<const ViewportSwizzleNV> const & viewportSwizzles,
|
|
|
7789 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7791
|
|
|
7792 // wrapper function for command vkCmdSetCoverageToColorEnableNV, see
|
|
|
7793 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html
|
|
|
7794 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7795 void setCoverageToColorEnableNV( Bool32 coverageToColorEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7796
|
|
|
7797 // wrapper function for command vkCmdSetCoverageToColorLocationNV, see
|
|
|
7798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html
|
|
|
7799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7800 void setCoverageToColorLocationNV( uint32_t coverageToColorLocation,
|
|
|
7801 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7802
|
|
|
7803 // wrapper function for command vkCmdSetCoverageModulationModeNV, see
|
|
|
7804 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html
|
|
|
7805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7806 void setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode,
|
|
|
7807 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7808
|
|
|
7809 // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see
|
|
|
7810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html
|
|
|
7811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7812 void setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable,
|
|
|
7813 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7814
|
|
|
7815 // wrapper function for command vkCmdSetCoverageModulationTableNV, see
|
|
|
7816 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html
|
|
|
7817 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7818 void setCoverageModulationTableNV( uint32_t coverageModulationTableCount,
|
|
|
7819 const float * pCoverageModulationTable,
|
|
|
7820 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7821 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7822 // wrapper function for command vkCmdSetCoverageModulationTableNV, see
|
|
|
7823 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html
|
|
|
7824 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7825 void setCoverageModulationTableNV( ArrayProxy<const float> const & coverageModulationTable,
|
|
|
7826 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7827 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7828
|
|
|
7829 // wrapper function for command vkCmdSetShadingRateImageEnableNV, see
|
|
|
7830 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html
|
|
|
7831 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7832 void setShadingRateImageEnableNV( Bool32 shadingRateImageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7833
|
|
|
7834 // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see
|
|
|
7835 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html
|
|
|
7836 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7837 void setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable,
|
|
|
7838 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7839
|
|
|
7840 // wrapper function for command vkCmdSetCoverageReductionModeNV, see
|
|
|
7841 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html
|
|
|
7842 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7843 void setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode,
|
|
|
7844 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7845
|
|
|
7846 //=== VK_ARM_tensors ===
|
|
|
7847
|
|
|
7848 // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html
|
|
|
7849 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7850 void copyTensorARM( const CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7851 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7852 // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html
|
|
|
7853 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7854 void copyTensorARM( const CopyTensorInfoARM & copyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7855 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7856
|
|
|
7857 //=== VK_NV_optical_flow ===
|
|
|
7858
|
|
|
7859 // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html
|
|
|
7860 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7861 void opticalFlowExecuteNV( OpticalFlowSessionNV session,
|
|
|
7862 const OpticalFlowExecuteInfoNV * pExecuteInfo,
|
|
|
7863 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7864 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7865 // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html
|
|
|
7866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7867 void opticalFlowExecuteNV( OpticalFlowSessionNV session,
|
|
|
7868 const OpticalFlowExecuteInfoNV & executeInfo,
|
|
|
7869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7870 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7871
|
|
|
7872 //=== VK_KHR_maintenance5 ===
|
|
|
7873
|
|
|
7874 // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html
|
|
|
7875 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7876 void bindIndexBuffer2KHR( Buffer buffer,
|
|
|
7877 DeviceSize offset,
|
|
|
7878 DeviceSize size,
|
|
|
7879 IndexType indexType,
|
|
|
7880 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7881
|
|
|
7882 //=== VK_EXT_shader_object ===
|
|
|
7883
|
|
|
7884 // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html
|
|
|
7885 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7886 void bindShadersEXT( uint32_t stageCount,
|
|
|
7887 const ShaderStageFlagBits * pStages,
|
|
|
7888 const ShaderEXT * pShaders,
|
|
|
7889 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7890 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7891 // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html
|
|
|
7892 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7893 void bindShadersEXT( ArrayProxy<const ShaderStageFlagBits> const & stages,
|
|
|
7894 ArrayProxy<const ShaderEXT> const & shaders,
|
|
|
7895 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
7896 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7897
|
|
|
7898 // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html
|
|
|
7899 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7900 void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode,
|
|
|
7901 const DepthClampRangeEXT * pDepthClampRange,
|
|
|
7902 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7903 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7904 // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html
|
|
|
7905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7906 void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode,
|
|
|
7907 Optional<const DepthClampRangeEXT> depthClampRange VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
7908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7909 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7910
|
|
|
7911 //=== VK_NV_cooperative_vector ===
|
|
|
7912
|
|
|
7913 // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see
|
|
|
7914 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html
|
|
|
7915 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7916 void convertCooperativeVectorMatrixNV( uint32_t infoCount,
|
|
|
7917 const ConvertCooperativeVectorMatrixInfoNV * pInfos,
|
|
|
7918 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7919 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7920 // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see
|
|
|
7921 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html
|
|
|
7922 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7923 void convertCooperativeVectorMatrixNV( ArrayProxy<const ConvertCooperativeVectorMatrixInfoNV> const & infos,
|
|
|
7924 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7926
|
|
|
7927 //=== VK_ARM_data_graph ===
|
|
|
7928
|
|
|
7929 // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html
|
|
|
7930 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7931 void dispatchDataGraphARM( DataGraphPipelineSessionARM session,
|
|
|
7932 const DataGraphPipelineDispatchInfoARM * pInfo,
|
|
|
7933 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7935 // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html
|
|
|
7936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7937 void dispatchDataGraphARM( DataGraphPipelineSessionARM session,
|
|
|
7938 Optional<const DataGraphPipelineDispatchInfoARM> info VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
7939 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7941
|
|
|
7942 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
7943
|
|
|
7944 // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see
|
|
|
7945 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html
|
|
|
7946 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7947 void setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask,
|
|
|
7948 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7949
|
|
|
7950 //=== VK_KHR_line_rasterization ===
|
|
|
7951
|
|
|
7952 // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html
|
|
|
7953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7954 void setLineStippleKHR( uint32_t lineStippleFactor,
|
|
|
7955 uint16_t lineStipplePattern,
|
|
|
7956 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7957
|
|
|
7958 //=== VK_KHR_maintenance6 ===
|
|
|
7959
|
|
|
7960 // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html
|
|
|
7961 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7962 void bindDescriptorSets2KHR( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
|
|
|
7963 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7965 // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html
|
|
|
7966 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7967 void bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo,
|
|
|
7968 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7970
|
|
|
7971 // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html
|
|
|
7972 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7973 void pushConstants2KHR( const PushConstantsInfo * pPushConstantsInfo,
|
|
|
7974 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7975 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7976 // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html
|
|
|
7977 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7978 void pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo,
|
|
|
7979 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7980 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7981
|
|
|
7982 // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html
|
|
|
7983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7984 void pushDescriptorSet2KHR( const PushDescriptorSetInfo * pPushDescriptorSetInfo,
|
|
|
7985 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7986 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7987 // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html
|
|
|
7988 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7989 void pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo,
|
|
|
7990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7991 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
7992
|
|
|
7993 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see
|
|
|
7994 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html
|
|
|
7995 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
7996 void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
|
|
|
7997 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
7998 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
7999 // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see
|
|
|
8000 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html
|
|
|
8001 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8002 void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
|
|
|
8003 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8005
|
|
|
8006 // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see
|
|
|
8007 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html
|
|
|
8008 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8009 void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,
|
|
|
8010 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8012 // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see
|
|
|
8013 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html
|
|
|
8014 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8015 void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,
|
|
|
8016 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8017 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8018
|
|
|
8019 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see
|
|
|
8020 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html
|
|
|
8021 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8022 void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,
|
|
|
8023 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8024 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8025 // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see
|
|
|
8026 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html
|
|
|
8027 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8028 void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,
|
|
|
8029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8030 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8031
|
|
|
8032 //=== VK_QCOM_tile_memory_heap ===
|
|
|
8033
|
|
|
8034 // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
|
|
|
8035 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8036 void bindTileMemoryQCOM( const TileMemoryBindInfoQCOM * pTileMemoryBindInfo,
|
|
|
8037 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8039 // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
|
|
|
8040 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8041 void bindTileMemoryQCOM( Optional<const TileMemoryBindInfoQCOM> tileMemoryBindInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
8042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8044
|
|
|
8045 //=== VK_KHR_copy_memory_indirect ===
|
|
|
8046
|
|
|
8047 // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
|
|
|
8048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8049 void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo,
|
|
|
8050 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8052 // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
|
|
|
8053 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8054 void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo,
|
|
|
8055 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8056 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8057
|
|
|
8058 // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
|
|
|
8059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
|
|
|
8060 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8061 void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo,
|
|
|
8062 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8064 // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
|
|
|
8065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
|
|
|
8066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8067 void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo,
|
|
|
8068 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8069 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8070
|
|
|
8071 //=== VK_EXT_memory_decompression ===
|
|
|
8072
|
|
|
8073 // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html
|
|
|
8074 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8075 void decompressMemoryEXT( const DecompressMemoryInfoEXT * pDecompressMemoryInfoEXT,
|
|
|
8076 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8078 // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html
|
|
|
8079 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8080 void decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT,
|
|
|
8081 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8082 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8083
|
|
|
8084 // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see
|
|
|
8085 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html
|
|
|
8086 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8087 void decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod,
|
|
|
8088 DeviceAddress indirectCommandsAddress,
|
|
|
8089 DeviceAddress indirectCommandsCountAddress,
|
|
|
8090 uint32_t maxDecompressionCount,
|
|
|
8091 uint32_t stride,
|
|
|
8092 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8093
|
|
|
8094 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
8095
|
|
|
8096 // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
|
|
|
8097 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html
|
|
|
8098 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8099 void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV * pCommandInfos,
|
|
|
8100 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8101 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8102 // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
|
|
|
8103 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html
|
|
|
8104 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8105 void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos,
|
|
|
8106 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8107 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8108
|
|
|
8109 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
8110
|
|
|
8111 // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see
|
|
|
8112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html
|
|
|
8113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8114 void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV * pBuildInfo,
|
|
|
8115 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8116 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8117 // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see
|
|
|
8118 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html
|
|
|
8119 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8120 void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo,
|
|
|
8121 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8122 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8123
|
|
|
8124 //=== VK_EXT_device_generated_commands ===
|
|
|
8125
|
|
|
8126 // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see
|
|
|
8127 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html
|
|
|
8128 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8129 void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
|
|
|
8130 CommandBuffer stateCommandBuffer,
|
|
|
8131 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8133 // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see
|
|
|
8134 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html
|
|
|
8135 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8136 void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo,
|
|
|
8137 CommandBuffer stateCommandBuffer,
|
|
|
8138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8140
|
|
|
8141 // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see
|
|
|
8142 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html
|
|
|
8143 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8144 void executeGeneratedCommandsEXT( Bool32 isPreprocessed,
|
|
|
8145 const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
|
|
|
8146 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8147 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8148 // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see
|
|
|
8149 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html
|
|
|
8150 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8151 void executeGeneratedCommandsEXT( Bool32 isPreprocessed,
|
|
|
8152 const GeneratedCommandsInfoEXT & generatedCommandsInfo,
|
|
|
8153 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8154 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8155
|
|
|
8156 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
8157
|
|
|
8158 // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
|
|
|
8159 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8160 void endRendering2EXT( const RenderingEndInfoKHR * pRenderingEndInfo,
|
|
|
8161 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8162 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8163 // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
|
|
|
8164 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8165 void endRendering2EXT( Optional<const RenderingEndInfoKHR> renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
8166 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8167 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8168
|
|
|
8169 //=== VK_EXT_custom_resolve ===
|
|
|
8170
|
|
|
8171 // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html
|
|
|
8172 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8173 void beginCustomResolveEXT( const BeginCustomResolveInfoEXT * pBeginCustomResolveInfo,
|
|
|
8174 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8176 // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html
|
|
|
8177 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8178 void beginCustomResolveEXT( Optional<const BeginCustomResolveInfoEXT> beginCustomResolveInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
8179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8181
|
|
|
8182 //=== VK_KHR_maintenance10 ===
|
|
|
8183
|
|
|
8184 // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html
|
|
|
8185 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8186 void endRendering2KHR( const RenderingEndInfoKHR * pRenderingEndInfo,
|
|
|
8187 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
8189 // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html
|
|
|
8190 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
8191 void endRendering2KHR( Optional<const RenderingEndInfoKHR> renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
8192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
8193 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
8194
|
|
|
8195 operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
|
|
|
8196 {
|
|
|
8197 return m_commandBuffer;
|
|
|
8198 }
|
|
|
8199
|
|
|
8200 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8201 {
|
|
|
8202 return m_commandBuffer != VK_NULL_HANDLE;
|
|
|
8203 }
|
|
|
8204
|
|
|
8205 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8206 {
|
|
|
8207 return m_commandBuffer == VK_NULL_HANDLE;
|
|
|
8208 }
|
|
|
8209
|
|
|
8210 private:
|
|
|
8211 VkCommandBuffer m_commandBuffer = {};
|
|
|
8212 };
|
|
|
8213
|
|
|
8214 template <>
|
|
|
8215 struct CppType<ObjectType, ObjectType::eCommandBuffer>
|
|
|
8216 {
|
|
|
8217 using Type = CommandBuffer;
|
|
|
8218 };
|
|
|
8219
|
|
|
8220 template <>
|
|
|
8221 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCommandBuffer>
|
|
|
8222 {
|
|
|
8223 using Type = CommandBuffer;
|
|
|
8224 };
|
|
|
8225
|
|
|
8226 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8227 template <>
|
|
|
8228 struct CppType<VkCommandBuffer, VK_NULL_HANDLE>
|
|
|
8229 {
|
|
|
8230 using Type = CommandBuffer;
|
|
|
8231 };
|
|
|
8232 #endif
|
|
|
8233
|
|
|
8234 template <>
|
|
|
8235 struct isVulkanHandleType<CommandBuffer>
|
|
|
8236 {
|
|
|
8237 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8238 };
|
|
|
8239
|
|
|
8240 // wrapper class for handle VkDeviceMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemory.html
|
|
|
8241 class DeviceMemory
|
|
|
8242 {
|
|
|
8243 public:
|
|
|
8244 using CType = VkDeviceMemory;
|
|
|
8245 using NativeType = VkDeviceMemory;
|
|
|
8246
|
|
|
8247 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory;
|
|
|
8248 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDeviceMemory;
|
|
|
8249
|
|
|
8250 public:
|
|
|
8251 DeviceMemory() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8252
|
|
|
8253 DeviceMemory( DeviceMemory const & rhs ) = default;
|
|
|
8254 DeviceMemory & operator=( DeviceMemory const & rhs ) = default;
|
|
|
8255
|
|
|
8256 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8257 DeviceMemory( DeviceMemory && rhs ) = default;
|
|
|
8258 DeviceMemory & operator=( DeviceMemory && rhs ) = default;
|
|
|
8259 #else
|
|
|
8260 DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( exchange( rhs.m_deviceMemory, {} ) ) {}
|
|
|
8261
|
|
|
8262 DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8263 {
|
|
|
8264 m_deviceMemory = exchange( rhs.m_deviceMemory, {} );
|
|
|
8265 return *this;
|
|
|
8266 }
|
|
|
8267 #endif
|
|
|
8268
|
|
|
8269 VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8270
|
|
|
8271 VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
|
|
|
8272
|
|
|
8273 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8274 DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
|
|
|
8275 {
|
|
|
8276 m_deviceMemory = deviceMemory;
|
|
|
8277 return *this;
|
|
|
8278 }
|
|
|
8279 #endif
|
|
|
8280
|
|
|
8281 DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8282 {
|
|
|
8283 m_deviceMemory = {};
|
|
|
8284 return *this;
|
|
|
8285 }
|
|
|
8286
|
|
|
8287 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
|
|
|
8288 {
|
|
|
8289 return m_deviceMemory;
|
|
|
8290 }
|
|
|
8291
|
|
|
8292 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8293 {
|
|
|
8294 return m_deviceMemory != VK_NULL_HANDLE;
|
|
|
8295 }
|
|
|
8296
|
|
|
8297 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8298 {
|
|
|
8299 return m_deviceMemory == VK_NULL_HANDLE;
|
|
|
8300 }
|
|
|
8301
|
|
|
8302 private:
|
|
|
8303 VkDeviceMemory m_deviceMemory = {};
|
|
|
8304 };
|
|
|
8305
|
|
|
8306 template <>
|
|
|
8307 struct CppType<ObjectType, ObjectType::eDeviceMemory>
|
|
|
8308 {
|
|
|
8309 using Type = DeviceMemory;
|
|
|
8310 };
|
|
|
8311
|
|
|
8312 template <>
|
|
|
8313 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDeviceMemory>
|
|
|
8314 {
|
|
|
8315 using Type = DeviceMemory;
|
|
|
8316 };
|
|
|
8317
|
|
|
8318 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8319 template <>
|
|
|
8320 struct CppType<VkDeviceMemory, VK_NULL_HANDLE>
|
|
|
8321 {
|
|
|
8322 using Type = DeviceMemory;
|
|
|
8323 };
|
|
|
8324 #endif
|
|
|
8325
|
|
|
8326 template <>
|
|
|
8327 struct isVulkanHandleType<DeviceMemory>
|
|
|
8328 {
|
|
|
8329 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8330 };
|
|
|
8331
|
|
|
8332 // wrapper class for handle VkVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionKHR.html
|
|
|
8333 class VideoSessionKHR
|
|
|
8334 {
|
|
|
8335 public:
|
|
|
8336 using CType = VkVideoSessionKHR;
|
|
|
8337 using NativeType = VkVideoSessionKHR;
|
|
|
8338
|
|
|
8339 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionKHR;
|
|
|
8340 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
8341
|
|
|
8342 public:
|
|
|
8343 VideoSessionKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8344
|
|
|
8345 VideoSessionKHR( VideoSessionKHR const & rhs ) = default;
|
|
|
8346 VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default;
|
|
|
8347
|
|
|
8348 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8349 VideoSessionKHR( VideoSessionKHR && rhs ) = default;
|
|
|
8350 VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default;
|
|
|
8351 #else
|
|
|
8352 VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( exchange( rhs.m_videoSessionKHR, {} ) ) {}
|
|
|
8353
|
|
|
8354 VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8355 {
|
|
|
8356 m_videoSessionKHR = exchange( rhs.m_videoSessionKHR, {} );
|
|
|
8357 return *this;
|
|
|
8358 }
|
|
|
8359 #endif
|
|
|
8360
|
|
|
8361 VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8362
|
|
|
8363 VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
|
|
|
8364
|
|
|
8365 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8366 VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
8367 {
|
|
|
8368 m_videoSessionKHR = videoSessionKHR;
|
|
|
8369 return *this;
|
|
|
8370 }
|
|
|
8371 #endif
|
|
|
8372
|
|
|
8373 VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8374 {
|
|
|
8375 m_videoSessionKHR = {};
|
|
|
8376 return *this;
|
|
|
8377 }
|
|
|
8378
|
|
|
8379 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
8380 {
|
|
|
8381 return m_videoSessionKHR;
|
|
|
8382 }
|
|
|
8383
|
|
|
8384 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8385 {
|
|
|
8386 return m_videoSessionKHR != VK_NULL_HANDLE;
|
|
|
8387 }
|
|
|
8388
|
|
|
8389 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8390 {
|
|
|
8391 return m_videoSessionKHR == VK_NULL_HANDLE;
|
|
|
8392 }
|
|
|
8393
|
|
|
8394 private:
|
|
|
8395 VkVideoSessionKHR m_videoSessionKHR = {};
|
|
|
8396 };
|
|
|
8397
|
|
|
8398 template <>
|
|
|
8399 struct CppType<ObjectType, ObjectType::eVideoSessionKHR>
|
|
|
8400 {
|
|
|
8401 using Type = VideoSessionKHR;
|
|
|
8402 };
|
|
|
8403
|
|
|
8404 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8405 template <>
|
|
|
8406 struct CppType<VkVideoSessionKHR, VK_NULL_HANDLE>
|
|
|
8407 {
|
|
|
8408 using Type = VideoSessionKHR;
|
|
|
8409 };
|
|
|
8410 #endif
|
|
|
8411
|
|
|
8412 template <>
|
|
|
8413 struct isVulkanHandleType<VideoSessionKHR>
|
|
|
8414 {
|
|
|
8415 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8416 };
|
|
|
8417
|
|
|
8418 // wrapper class for handle VkDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeferredOperationKHR.html
|
|
|
8419 class DeferredOperationKHR
|
|
|
8420 {
|
|
|
8421 public:
|
|
|
8422 using CType = VkDeferredOperationKHR;
|
|
|
8423 using NativeType = VkDeferredOperationKHR;
|
|
|
8424
|
|
|
8425 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeferredOperationKHR;
|
|
|
8426 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
8427
|
|
|
8428 public:
|
|
|
8429 DeferredOperationKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8430
|
|
|
8431 DeferredOperationKHR( DeferredOperationKHR const & rhs ) = default;
|
|
|
8432 DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default;
|
|
|
8433
|
|
|
8434 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8435 DeferredOperationKHR( DeferredOperationKHR && rhs ) = default;
|
|
|
8436 DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default;
|
|
|
8437 #else
|
|
|
8438 DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( exchange( rhs.m_deferredOperationKHR, {} ) ) {}
|
|
|
8439
|
|
|
8440 DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8441 {
|
|
|
8442 m_deferredOperationKHR = exchange( rhs.m_deferredOperationKHR, {} );
|
|
|
8443 return *this;
|
|
|
8444 }
|
|
|
8445 #endif
|
|
|
8446
|
|
|
8447 VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8448
|
|
|
8449 VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
8450 : m_deferredOperationKHR( deferredOperationKHR )
|
|
|
8451 {
|
|
|
8452 }
|
|
|
8453
|
|
|
8454 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8455 DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
8456 {
|
|
|
8457 m_deferredOperationKHR = deferredOperationKHR;
|
|
|
8458 return *this;
|
|
|
8459 }
|
|
|
8460 #endif
|
|
|
8461
|
|
|
8462 DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8463 {
|
|
|
8464 m_deferredOperationKHR = {};
|
|
|
8465 return *this;
|
|
|
8466 }
|
|
|
8467
|
|
|
8468 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
8469 {
|
|
|
8470 return m_deferredOperationKHR;
|
|
|
8471 }
|
|
|
8472
|
|
|
8473 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8474 {
|
|
|
8475 return m_deferredOperationKHR != VK_NULL_HANDLE;
|
|
|
8476 }
|
|
|
8477
|
|
|
8478 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8479 {
|
|
|
8480 return m_deferredOperationKHR == VK_NULL_HANDLE;
|
|
|
8481 }
|
|
|
8482
|
|
|
8483 private:
|
|
|
8484 VkDeferredOperationKHR m_deferredOperationKHR = {};
|
|
|
8485 };
|
|
|
8486
|
|
|
8487 template <>
|
|
|
8488 struct CppType<ObjectType, ObjectType::eDeferredOperationKHR>
|
|
|
8489 {
|
|
|
8490 using Type = DeferredOperationKHR;
|
|
|
8491 };
|
|
|
8492
|
|
|
8493 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8494 template <>
|
|
|
8495 struct CppType<VkDeferredOperationKHR, VK_NULL_HANDLE>
|
|
|
8496 {
|
|
|
8497 using Type = DeferredOperationKHR;
|
|
|
8498 };
|
|
|
8499 #endif
|
|
|
8500
|
|
|
8501 template <>
|
|
|
8502 struct isVulkanHandleType<DeferredOperationKHR>
|
|
|
8503 {
|
|
|
8504 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8505 };
|
|
|
8506
|
|
|
8507 // wrapper class for handle VkBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionFUCHSIA.html
|
|
|
8508 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
8509 class BufferCollectionFUCHSIA
|
|
|
8510 {
|
|
|
8511 public:
|
|
|
8512 using CType = VkBufferCollectionFUCHSIA;
|
|
|
8513 using NativeType = VkBufferCollectionFUCHSIA;
|
|
|
8514
|
|
|
8515 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferCollectionFUCHSIA;
|
|
|
8516 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
|
|
|
8517
|
|
|
8518 public:
|
|
|
8519 BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8520
|
|
|
8521 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs ) = default;
|
|
|
8522 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default;
|
|
|
8523
|
|
|
8524 # if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8525 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) = default;
|
|
|
8526 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default;
|
|
|
8527 # else
|
|
|
8528 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferCollectionFUCHSIA( exchange( rhs.m_bufferCollectionFUCHSIA, {} ) )
|
|
|
8529 {
|
|
|
8530 }
|
|
|
8531
|
|
|
8532 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8533 {
|
|
|
8534 m_bufferCollectionFUCHSIA = exchange( rhs.m_bufferCollectionFUCHSIA, {} );
|
|
|
8535 return *this;
|
|
|
8536 }
|
|
|
8537 # endif
|
|
|
8538
|
|
|
8539 VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8540
|
|
|
8541 VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
|
|
|
8542 : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
|
|
|
8543 {
|
|
|
8544 }
|
|
|
8545
|
|
|
8546 # if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8547 BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
|
|
|
8548 {
|
|
|
8549 m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
|
|
|
8550 return *this;
|
|
|
8551 }
|
|
|
8552 # endif
|
|
|
8553
|
|
|
8554 BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8555 {
|
|
|
8556 m_bufferCollectionFUCHSIA = {};
|
|
|
8557 return *this;
|
|
|
8558 }
|
|
|
8559
|
|
|
8560 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
|
|
|
8561 {
|
|
|
8562 return m_bufferCollectionFUCHSIA;
|
|
|
8563 }
|
|
|
8564
|
|
|
8565 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8566 {
|
|
|
8567 return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
|
|
|
8568 }
|
|
|
8569
|
|
|
8570 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8571 {
|
|
|
8572 return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
|
|
|
8573 }
|
|
|
8574
|
|
|
8575 private:
|
|
|
8576 VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
|
|
|
8577 };
|
|
|
8578
|
|
|
8579 template <>
|
|
|
8580 struct CppType<ObjectType, ObjectType::eBufferCollectionFUCHSIA>
|
|
|
8581 {
|
|
|
8582 using Type = BufferCollectionFUCHSIA;
|
|
|
8583 };
|
|
|
8584
|
|
|
8585 template <>
|
|
|
8586 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
|
|
|
8587 {
|
|
|
8588 using Type = BufferCollectionFUCHSIA;
|
|
|
8589 };
|
|
|
8590
|
|
|
8591 # if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8592 template <>
|
|
|
8593 struct CppType<VkBufferCollectionFUCHSIA, VK_NULL_HANDLE>
|
|
|
8594 {
|
|
|
8595 using Type = BufferCollectionFUCHSIA;
|
|
|
8596 };
|
|
|
8597 # endif
|
|
|
8598
|
|
|
8599 template <>
|
|
|
8600 struct isVulkanHandleType<BufferCollectionFUCHSIA>
|
|
|
8601 {
|
|
|
8602 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8603 };
|
|
|
8604 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
8605
|
|
|
8606 // wrapper class for handle VkBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferView.html
|
|
|
8607 class BufferView
|
|
|
8608 {
|
|
|
8609 public:
|
|
|
8610 using CType = VkBufferView;
|
|
|
8611 using NativeType = VkBufferView;
|
|
|
8612
|
|
|
8613 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView;
|
|
|
8614 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferView;
|
|
|
8615
|
|
|
8616 public:
|
|
|
8617 BufferView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8618
|
|
|
8619 BufferView( BufferView const & rhs ) = default;
|
|
|
8620 BufferView & operator=( BufferView const & rhs ) = default;
|
|
|
8621
|
|
|
8622 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8623 BufferView( BufferView && rhs ) = default;
|
|
|
8624 BufferView & operator=( BufferView && rhs ) = default;
|
|
|
8625 #else
|
|
|
8626 BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferView( exchange( rhs.m_bufferView, {} ) ) {}
|
|
|
8627
|
|
|
8628 BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8629 {
|
|
|
8630 m_bufferView = exchange( rhs.m_bufferView, {} );
|
|
|
8631 return *this;
|
|
|
8632 }
|
|
|
8633 #endif
|
|
|
8634
|
|
|
8635 VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8636
|
|
|
8637 VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
|
|
|
8638
|
|
|
8639 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8640 BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
|
|
|
8641 {
|
|
|
8642 m_bufferView = bufferView;
|
|
|
8643 return *this;
|
|
|
8644 }
|
|
|
8645 #endif
|
|
|
8646
|
|
|
8647 BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8648 {
|
|
|
8649 m_bufferView = {};
|
|
|
8650 return *this;
|
|
|
8651 }
|
|
|
8652
|
|
|
8653 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
|
|
|
8654 {
|
|
|
8655 return m_bufferView;
|
|
|
8656 }
|
|
|
8657
|
|
|
8658 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8659 {
|
|
|
8660 return m_bufferView != VK_NULL_HANDLE;
|
|
|
8661 }
|
|
|
8662
|
|
|
8663 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8664 {
|
|
|
8665 return m_bufferView == VK_NULL_HANDLE;
|
|
|
8666 }
|
|
|
8667
|
|
|
8668 private:
|
|
|
8669 VkBufferView m_bufferView = {};
|
|
|
8670 };
|
|
|
8671
|
|
|
8672 template <>
|
|
|
8673 struct CppType<ObjectType, ObjectType::eBufferView>
|
|
|
8674 {
|
|
|
8675 using Type = BufferView;
|
|
|
8676 };
|
|
|
8677
|
|
|
8678 template <>
|
|
|
8679 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eBufferView>
|
|
|
8680 {
|
|
|
8681 using Type = BufferView;
|
|
|
8682 };
|
|
|
8683
|
|
|
8684 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8685 template <>
|
|
|
8686 struct CppType<VkBufferView, VK_NULL_HANDLE>
|
|
|
8687 {
|
|
|
8688 using Type = BufferView;
|
|
|
8689 };
|
|
|
8690 #endif
|
|
|
8691
|
|
|
8692 template <>
|
|
|
8693 struct isVulkanHandleType<BufferView>
|
|
|
8694 {
|
|
|
8695 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8696 };
|
|
|
8697
|
|
|
8698 // wrapper class for handle VkCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPool.html
|
|
|
8699 class CommandPool
|
|
|
8700 {
|
|
|
8701 public:
|
|
|
8702 using CType = VkCommandPool;
|
|
|
8703 using NativeType = VkCommandPool;
|
|
|
8704
|
|
|
8705 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool;
|
|
|
8706 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandPool;
|
|
|
8707
|
|
|
8708 public:
|
|
|
8709 CommandPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8710
|
|
|
8711 CommandPool( CommandPool const & rhs ) = default;
|
|
|
8712 CommandPool & operator=( CommandPool const & rhs ) = default;
|
|
|
8713
|
|
|
8714 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8715 CommandPool( CommandPool && rhs ) = default;
|
|
|
8716 CommandPool & operator=( CommandPool && rhs ) = default;
|
|
|
8717 #else
|
|
|
8718 CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT : m_commandPool( exchange( rhs.m_commandPool, {} ) ) {}
|
|
|
8719
|
|
|
8720 CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8721 {
|
|
|
8722 m_commandPool = exchange( rhs.m_commandPool, {} );
|
|
|
8723 return *this;
|
|
|
8724 }
|
|
|
8725 #endif
|
|
|
8726
|
|
|
8727 VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8728
|
|
|
8729 VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
|
|
|
8730
|
|
|
8731 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8732 CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
|
|
|
8733 {
|
|
|
8734 m_commandPool = commandPool;
|
|
|
8735 return *this;
|
|
|
8736 }
|
|
|
8737 #endif
|
|
|
8738
|
|
|
8739 CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8740 {
|
|
|
8741 m_commandPool = {};
|
|
|
8742 return *this;
|
|
|
8743 }
|
|
|
8744
|
|
|
8745 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
|
|
|
8746 {
|
|
|
8747 return m_commandPool;
|
|
|
8748 }
|
|
|
8749
|
|
|
8750 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8751 {
|
|
|
8752 return m_commandPool != VK_NULL_HANDLE;
|
|
|
8753 }
|
|
|
8754
|
|
|
8755 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8756 {
|
|
|
8757 return m_commandPool == VK_NULL_HANDLE;
|
|
|
8758 }
|
|
|
8759
|
|
|
8760 private:
|
|
|
8761 VkCommandPool m_commandPool = {};
|
|
|
8762 };
|
|
|
8763
|
|
|
8764 template <>
|
|
|
8765 struct CppType<ObjectType, ObjectType::eCommandPool>
|
|
|
8766 {
|
|
|
8767 using Type = CommandPool;
|
|
|
8768 };
|
|
|
8769
|
|
|
8770 template <>
|
|
|
8771 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCommandPool>
|
|
|
8772 {
|
|
|
8773 using Type = CommandPool;
|
|
|
8774 };
|
|
|
8775
|
|
|
8776 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8777 template <>
|
|
|
8778 struct CppType<VkCommandPool, VK_NULL_HANDLE>
|
|
|
8779 {
|
|
|
8780 using Type = CommandPool;
|
|
|
8781 };
|
|
|
8782 #endif
|
|
|
8783
|
|
|
8784 template <>
|
|
|
8785 struct isVulkanHandleType<CommandPool>
|
|
|
8786 {
|
|
|
8787 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8788 };
|
|
|
8789
|
|
|
8790 // wrapper class for handle VkPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCache.html
|
|
|
8791 class PipelineCache
|
|
|
8792 {
|
|
|
8793 public:
|
|
|
8794 using CType = VkPipelineCache;
|
|
|
8795 using NativeType = VkPipelineCache;
|
|
|
8796
|
|
|
8797 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache;
|
|
|
8798 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineCache;
|
|
|
8799
|
|
|
8800 public:
|
|
|
8801 PipelineCache() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8802
|
|
|
8803 PipelineCache( PipelineCache const & rhs ) = default;
|
|
|
8804 PipelineCache & operator=( PipelineCache const & rhs ) = default;
|
|
|
8805
|
|
|
8806 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8807 PipelineCache( PipelineCache && rhs ) = default;
|
|
|
8808 PipelineCache & operator=( PipelineCache && rhs ) = default;
|
|
|
8809 #else
|
|
|
8810 PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( exchange( rhs.m_pipelineCache, {} ) ) {}
|
|
|
8811
|
|
|
8812 PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8813 {
|
|
|
8814 m_pipelineCache = exchange( rhs.m_pipelineCache, {} );
|
|
|
8815 return *this;
|
|
|
8816 }
|
|
|
8817 #endif
|
|
|
8818
|
|
|
8819 VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8820
|
|
|
8821 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
|
|
|
8822
|
|
|
8823 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8824 PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
|
|
|
8825 {
|
|
|
8826 m_pipelineCache = pipelineCache;
|
|
|
8827 return *this;
|
|
|
8828 }
|
|
|
8829 #endif
|
|
|
8830
|
|
|
8831 PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8832 {
|
|
|
8833 m_pipelineCache = {};
|
|
|
8834 return *this;
|
|
|
8835 }
|
|
|
8836
|
|
|
8837 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
|
|
|
8838 {
|
|
|
8839 return m_pipelineCache;
|
|
|
8840 }
|
|
|
8841
|
|
|
8842 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8843 {
|
|
|
8844 return m_pipelineCache != VK_NULL_HANDLE;
|
|
|
8845 }
|
|
|
8846
|
|
|
8847 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8848 {
|
|
|
8849 return m_pipelineCache == VK_NULL_HANDLE;
|
|
|
8850 }
|
|
|
8851
|
|
|
8852 private:
|
|
|
8853 VkPipelineCache m_pipelineCache = {};
|
|
|
8854 };
|
|
|
8855
|
|
|
8856 template <>
|
|
|
8857 struct CppType<ObjectType, ObjectType::ePipelineCache>
|
|
|
8858 {
|
|
|
8859 using Type = PipelineCache;
|
|
|
8860 };
|
|
|
8861
|
|
|
8862 template <>
|
|
|
8863 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePipelineCache>
|
|
|
8864 {
|
|
|
8865 using Type = PipelineCache;
|
|
|
8866 };
|
|
|
8867
|
|
|
8868 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8869 template <>
|
|
|
8870 struct CppType<VkPipelineCache, VK_NULL_HANDLE>
|
|
|
8871 {
|
|
|
8872 using Type = PipelineCache;
|
|
|
8873 };
|
|
|
8874 #endif
|
|
|
8875
|
|
|
8876 template <>
|
|
|
8877 struct isVulkanHandleType<PipelineCache>
|
|
|
8878 {
|
|
|
8879 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8880 };
|
|
|
8881
|
|
|
8882 // wrapper class for handle VkCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionNVX.html
|
|
|
8883 class CuFunctionNVX
|
|
|
8884 {
|
|
|
8885 public:
|
|
|
8886 using CType = VkCuFunctionNVX;
|
|
|
8887 using NativeType = VkCuFunctionNVX;
|
|
|
8888
|
|
|
8889 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuFunctionNVX;
|
|
|
8890 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuFunctionNVX;
|
|
|
8891
|
|
|
8892 public:
|
|
|
8893 CuFunctionNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8894
|
|
|
8895 CuFunctionNVX( CuFunctionNVX const & rhs ) = default;
|
|
|
8896 CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default;
|
|
|
8897
|
|
|
8898 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8899 CuFunctionNVX( CuFunctionNVX && rhs ) = default;
|
|
|
8900 CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default;
|
|
|
8901 #else
|
|
|
8902 CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( exchange( rhs.m_cuFunctionNVX, {} ) ) {}
|
|
|
8903
|
|
|
8904 CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8905 {
|
|
|
8906 m_cuFunctionNVX = exchange( rhs.m_cuFunctionNVX, {} );
|
|
|
8907 return *this;
|
|
|
8908 }
|
|
|
8909 #endif
|
|
|
8910
|
|
|
8911 VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
8912
|
|
|
8913 VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
|
|
|
8914
|
|
|
8915 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
8916 CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
|
|
|
8917 {
|
|
|
8918 m_cuFunctionNVX = cuFunctionNVX;
|
|
|
8919 return *this;
|
|
|
8920 }
|
|
|
8921 #endif
|
|
|
8922
|
|
|
8923 CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
8924 {
|
|
|
8925 m_cuFunctionNVX = {};
|
|
|
8926 return *this;
|
|
|
8927 }
|
|
|
8928
|
|
|
8929 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
|
|
|
8930 {
|
|
|
8931 return m_cuFunctionNVX;
|
|
|
8932 }
|
|
|
8933
|
|
|
8934 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
8935 {
|
|
|
8936 return m_cuFunctionNVX != VK_NULL_HANDLE;
|
|
|
8937 }
|
|
|
8938
|
|
|
8939 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
8940 {
|
|
|
8941 return m_cuFunctionNVX == VK_NULL_HANDLE;
|
|
|
8942 }
|
|
|
8943
|
|
|
8944 private:
|
|
|
8945 VkCuFunctionNVX m_cuFunctionNVX = {};
|
|
|
8946 };
|
|
|
8947
|
|
|
8948 template <>
|
|
|
8949 struct CppType<ObjectType, ObjectType::eCuFunctionNVX>
|
|
|
8950 {
|
|
|
8951 using Type = CuFunctionNVX;
|
|
|
8952 };
|
|
|
8953
|
|
|
8954 template <>
|
|
|
8955 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCuFunctionNVX>
|
|
|
8956 {
|
|
|
8957 using Type = CuFunctionNVX;
|
|
|
8958 };
|
|
|
8959
|
|
|
8960 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
8961 template <>
|
|
|
8962 struct CppType<VkCuFunctionNVX, VK_NULL_HANDLE>
|
|
|
8963 {
|
|
|
8964 using Type = CuFunctionNVX;
|
|
|
8965 };
|
|
|
8966 #endif
|
|
|
8967
|
|
|
8968 template <>
|
|
|
8969 struct isVulkanHandleType<CuFunctionNVX>
|
|
|
8970 {
|
|
|
8971 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
8972 };
|
|
|
8973
|
|
|
8974 // wrapper class for handle VkCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleNVX.html
|
|
|
8975 class CuModuleNVX
|
|
|
8976 {
|
|
|
8977 public:
|
|
|
8978 using CType = VkCuModuleNVX;
|
|
|
8979 using NativeType = VkCuModuleNVX;
|
|
|
8980
|
|
|
8981 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuModuleNVX;
|
|
|
8982 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuModuleNVX;
|
|
|
8983
|
|
|
8984 public:
|
|
|
8985 CuModuleNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
8986
|
|
|
8987 CuModuleNVX( CuModuleNVX const & rhs ) = default;
|
|
|
8988 CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default;
|
|
|
8989
|
|
|
8990 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
8991 CuModuleNVX( CuModuleNVX && rhs ) = default;
|
|
|
8992 CuModuleNVX & operator=( CuModuleNVX && rhs ) = default;
|
|
|
8993 #else
|
|
|
8994 CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( exchange( rhs.m_cuModuleNVX, {} ) ) {}
|
|
|
8995
|
|
|
8996 CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
8997 {
|
|
|
8998 m_cuModuleNVX = exchange( rhs.m_cuModuleNVX, {} );
|
|
|
8999 return *this;
|
|
|
9000 }
|
|
|
9001 #endif
|
|
|
9002
|
|
|
9003 VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9004
|
|
|
9005 VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
|
|
|
9006
|
|
|
9007 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9008 CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
|
|
|
9009 {
|
|
|
9010 m_cuModuleNVX = cuModuleNVX;
|
|
|
9011 return *this;
|
|
|
9012 }
|
|
|
9013 #endif
|
|
|
9014
|
|
|
9015 CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9016 {
|
|
|
9017 m_cuModuleNVX = {};
|
|
|
9018 return *this;
|
|
|
9019 }
|
|
|
9020
|
|
|
9021 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
|
|
|
9022 {
|
|
|
9023 return m_cuModuleNVX;
|
|
|
9024 }
|
|
|
9025
|
|
|
9026 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9027 {
|
|
|
9028 return m_cuModuleNVX != VK_NULL_HANDLE;
|
|
|
9029 }
|
|
|
9030
|
|
|
9031 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9032 {
|
|
|
9033 return m_cuModuleNVX == VK_NULL_HANDLE;
|
|
|
9034 }
|
|
|
9035
|
|
|
9036 private:
|
|
|
9037 VkCuModuleNVX m_cuModuleNVX = {};
|
|
|
9038 };
|
|
|
9039
|
|
|
9040 template <>
|
|
|
9041 struct CppType<ObjectType, ObjectType::eCuModuleNVX>
|
|
|
9042 {
|
|
|
9043 using Type = CuModuleNVX;
|
|
|
9044 };
|
|
|
9045
|
|
|
9046 template <>
|
|
|
9047 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCuModuleNVX>
|
|
|
9048 {
|
|
|
9049 using Type = CuModuleNVX;
|
|
|
9050 };
|
|
|
9051
|
|
|
9052 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9053 template <>
|
|
|
9054 struct CppType<VkCuModuleNVX, VK_NULL_HANDLE>
|
|
|
9055 {
|
|
|
9056 using Type = CuModuleNVX;
|
|
|
9057 };
|
|
|
9058 #endif
|
|
|
9059
|
|
|
9060 template <>
|
|
|
9061 struct isVulkanHandleType<CuModuleNVX>
|
|
|
9062 {
|
|
|
9063 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9064 };
|
|
|
9065
|
|
|
9066 // wrapper class for handle VkCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionNV.html
|
|
|
9067 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9068 class CudaFunctionNV
|
|
|
9069 {
|
|
|
9070 public:
|
|
|
9071 using CType = VkCudaFunctionNV;
|
|
|
9072 using NativeType = VkCudaFunctionNV;
|
|
|
9073
|
|
|
9074 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaFunctionNV;
|
|
|
9075 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaFunctionNV;
|
|
|
9076
|
|
|
9077 public:
|
|
|
9078 CudaFunctionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9079
|
|
|
9080 CudaFunctionNV( CudaFunctionNV const & rhs ) = default;
|
|
|
9081 CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default;
|
|
|
9082
|
|
|
9083 # if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9084 CudaFunctionNV( CudaFunctionNV && rhs ) = default;
|
|
|
9085 CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default;
|
|
|
9086 # else
|
|
|
9087 CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( exchange( rhs.m_cudaFunctionNV, {} ) ) {}
|
|
|
9088
|
|
|
9089 CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9090 {
|
|
|
9091 m_cudaFunctionNV = exchange( rhs.m_cudaFunctionNV, {} );
|
|
|
9092 return *this;
|
|
|
9093 }
|
|
|
9094 # endif
|
|
|
9095
|
|
|
9096 VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9097
|
|
|
9098 VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}
|
|
|
9099
|
|
|
9100 # if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9101 CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT
|
|
|
9102 {
|
|
|
9103 m_cudaFunctionNV = cudaFunctionNV;
|
|
|
9104 return *this;
|
|
|
9105 }
|
|
|
9106 # endif
|
|
|
9107
|
|
|
9108 CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9109 {
|
|
|
9110 m_cudaFunctionNV = {};
|
|
|
9111 return *this;
|
|
|
9112 }
|
|
|
9113
|
|
|
9114 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT
|
|
|
9115 {
|
|
|
9116 return m_cudaFunctionNV;
|
|
|
9117 }
|
|
|
9118
|
|
|
9119 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9120 {
|
|
|
9121 return m_cudaFunctionNV != VK_NULL_HANDLE;
|
|
|
9122 }
|
|
|
9123
|
|
|
9124 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9125 {
|
|
|
9126 return m_cudaFunctionNV == VK_NULL_HANDLE;
|
|
|
9127 }
|
|
|
9128
|
|
|
9129 private:
|
|
|
9130 VkCudaFunctionNV m_cudaFunctionNV = {};
|
|
|
9131 };
|
|
|
9132
|
|
|
9133 template <>
|
|
|
9134 struct CppType<ObjectType, ObjectType::eCudaFunctionNV>
|
|
|
9135 {
|
|
|
9136 using Type = CudaFunctionNV;
|
|
|
9137 };
|
|
|
9138
|
|
|
9139 template <>
|
|
|
9140 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCudaFunctionNV>
|
|
|
9141 {
|
|
|
9142 using Type = CudaFunctionNV;
|
|
|
9143 };
|
|
|
9144
|
|
|
9145 # if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9146 template <>
|
|
|
9147 struct CppType<VkCudaFunctionNV, VK_NULL_HANDLE>
|
|
|
9148 {
|
|
|
9149 using Type = CudaFunctionNV;
|
|
|
9150 };
|
|
|
9151 # endif
|
|
|
9152
|
|
|
9153 template <>
|
|
|
9154 struct isVulkanHandleType<CudaFunctionNV>
|
|
|
9155 {
|
|
|
9156 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9157 };
|
|
|
9158 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9159
|
|
|
9160 // wrapper class for handle VkCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleNV.html
|
|
|
9161 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9162 class CudaModuleNV
|
|
|
9163 {
|
|
|
9164 public:
|
|
|
9165 using CType = VkCudaModuleNV;
|
|
|
9166 using NativeType = VkCudaModuleNV;
|
|
|
9167
|
|
|
9168 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaModuleNV;
|
|
|
9169 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaModuleNV;
|
|
|
9170
|
|
|
9171 public:
|
|
|
9172 CudaModuleNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9173
|
|
|
9174 CudaModuleNV( CudaModuleNV const & rhs ) = default;
|
|
|
9175 CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default;
|
|
|
9176
|
|
|
9177 # if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9178 CudaModuleNV( CudaModuleNV && rhs ) = default;
|
|
|
9179 CudaModuleNV & operator=( CudaModuleNV && rhs ) = default;
|
|
|
9180 # else
|
|
|
9181 CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( exchange( rhs.m_cudaModuleNV, {} ) ) {}
|
|
|
9182
|
|
|
9183 CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9184 {
|
|
|
9185 m_cudaModuleNV = exchange( rhs.m_cudaModuleNV, {} );
|
|
|
9186 return *this;
|
|
|
9187 }
|
|
|
9188 # endif
|
|
|
9189
|
|
|
9190 VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9191
|
|
|
9192 VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}
|
|
|
9193
|
|
|
9194 # if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9195 CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT
|
|
|
9196 {
|
|
|
9197 m_cudaModuleNV = cudaModuleNV;
|
|
|
9198 return *this;
|
|
|
9199 }
|
|
|
9200 # endif
|
|
|
9201
|
|
|
9202 CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9203 {
|
|
|
9204 m_cudaModuleNV = {};
|
|
|
9205 return *this;
|
|
|
9206 }
|
|
|
9207
|
|
|
9208 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT
|
|
|
9209 {
|
|
|
9210 return m_cudaModuleNV;
|
|
|
9211 }
|
|
|
9212
|
|
|
9213 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9214 {
|
|
|
9215 return m_cudaModuleNV != VK_NULL_HANDLE;
|
|
|
9216 }
|
|
|
9217
|
|
|
9218 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9219 {
|
|
|
9220 return m_cudaModuleNV == VK_NULL_HANDLE;
|
|
|
9221 }
|
|
|
9222
|
|
|
9223 private:
|
|
|
9224 VkCudaModuleNV m_cudaModuleNV = {};
|
|
|
9225 };
|
|
|
9226
|
|
|
9227 template <>
|
|
|
9228 struct CppType<ObjectType, ObjectType::eCudaModuleNV>
|
|
|
9229 {
|
|
|
9230 using Type = CudaModuleNV;
|
|
|
9231 };
|
|
|
9232
|
|
|
9233 template <>
|
|
|
9234 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eCudaModuleNV>
|
|
|
9235 {
|
|
|
9236 using Type = CudaModuleNV;
|
|
|
9237 };
|
|
|
9238
|
|
|
9239 # if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9240 template <>
|
|
|
9241 struct CppType<VkCudaModuleNV, VK_NULL_HANDLE>
|
|
|
9242 {
|
|
|
9243 using Type = CudaModuleNV;
|
|
|
9244 };
|
|
|
9245 # endif
|
|
|
9246
|
|
|
9247 template <>
|
|
|
9248 struct isVulkanHandleType<CudaModuleNV>
|
|
|
9249 {
|
|
|
9250 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9251 };
|
|
|
9252 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9253
|
|
|
9254 // wrapper class for handle VkDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPool.html
|
|
|
9255 class DescriptorPool
|
|
|
9256 {
|
|
|
9257 public:
|
|
|
9258 using CType = VkDescriptorPool;
|
|
|
9259 using NativeType = VkDescriptorPool;
|
|
|
9260
|
|
|
9261 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool;
|
|
|
9262 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorPool;
|
|
|
9263
|
|
|
9264 public:
|
|
|
9265 DescriptorPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9266
|
|
|
9267 DescriptorPool( DescriptorPool const & rhs ) = default;
|
|
|
9268 DescriptorPool & operator=( DescriptorPool const & rhs ) = default;
|
|
|
9269
|
|
|
9270 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9271 DescriptorPool( DescriptorPool && rhs ) = default;
|
|
|
9272 DescriptorPool & operator=( DescriptorPool && rhs ) = default;
|
|
|
9273 #else
|
|
|
9274 DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) {}
|
|
|
9275
|
|
|
9276 DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9277 {
|
|
|
9278 m_descriptorPool = exchange( rhs.m_descriptorPool, {} );
|
|
|
9279 return *this;
|
|
|
9280 }
|
|
|
9281 #endif
|
|
|
9282
|
|
|
9283 VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9284
|
|
|
9285 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
|
|
|
9286
|
|
|
9287 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9288 DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
|
|
|
9289 {
|
|
|
9290 m_descriptorPool = descriptorPool;
|
|
|
9291 return *this;
|
|
|
9292 }
|
|
|
9293 #endif
|
|
|
9294
|
|
|
9295 DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9296 {
|
|
|
9297 m_descriptorPool = {};
|
|
|
9298 return *this;
|
|
|
9299 }
|
|
|
9300
|
|
|
9301 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
|
|
|
9302 {
|
|
|
9303 return m_descriptorPool;
|
|
|
9304 }
|
|
|
9305
|
|
|
9306 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9307 {
|
|
|
9308 return m_descriptorPool != VK_NULL_HANDLE;
|
|
|
9309 }
|
|
|
9310
|
|
|
9311 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9312 {
|
|
|
9313 return m_descriptorPool == VK_NULL_HANDLE;
|
|
|
9314 }
|
|
|
9315
|
|
|
9316 private:
|
|
|
9317 VkDescriptorPool m_descriptorPool = {};
|
|
|
9318 };
|
|
|
9319
|
|
|
9320 template <>
|
|
|
9321 struct CppType<ObjectType, ObjectType::eDescriptorPool>
|
|
|
9322 {
|
|
|
9323 using Type = DescriptorPool;
|
|
|
9324 };
|
|
|
9325
|
|
|
9326 template <>
|
|
|
9327 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorPool>
|
|
|
9328 {
|
|
|
9329 using Type = DescriptorPool;
|
|
|
9330 };
|
|
|
9331
|
|
|
9332 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9333 template <>
|
|
|
9334 struct CppType<VkDescriptorPool, VK_NULL_HANDLE>
|
|
|
9335 {
|
|
|
9336 using Type = DescriptorPool;
|
|
|
9337 };
|
|
|
9338 #endif
|
|
|
9339
|
|
|
9340 template <>
|
|
|
9341 struct isVulkanHandleType<DescriptorPool>
|
|
|
9342 {
|
|
|
9343 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9344 };
|
|
|
9345
|
|
|
9346 // wrapper class for handle VkDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayout.html
|
|
|
9347 class DescriptorSetLayout
|
|
|
9348 {
|
|
|
9349 public:
|
|
|
9350 using CType = VkDescriptorSetLayout;
|
|
|
9351 using NativeType = VkDescriptorSetLayout;
|
|
|
9352
|
|
|
9353 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout;
|
|
|
9354 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSetLayout;
|
|
|
9355
|
|
|
9356 public:
|
|
|
9357 DescriptorSetLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9358
|
|
|
9359 DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default;
|
|
|
9360 DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;
|
|
|
9361
|
|
|
9362 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9363 DescriptorSetLayout( DescriptorSetLayout && rhs ) = default;
|
|
|
9364 DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default;
|
|
|
9365 #else
|
|
|
9366 DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( exchange( rhs.m_descriptorSetLayout, {} ) ) {}
|
|
|
9367
|
|
|
9368 DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9369 {
|
|
|
9370 m_descriptorSetLayout = exchange( rhs.m_descriptorSetLayout, {} );
|
|
|
9371 return *this;
|
|
|
9372 }
|
|
|
9373 #endif
|
|
|
9374
|
|
|
9375 VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9376
|
|
|
9377 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
|
|
|
9378 : m_descriptorSetLayout( descriptorSetLayout )
|
|
|
9379 {
|
|
|
9380 }
|
|
|
9381
|
|
|
9382 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9383 DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
|
|
|
9384 {
|
|
|
9385 m_descriptorSetLayout = descriptorSetLayout;
|
|
|
9386 return *this;
|
|
|
9387 }
|
|
|
9388 #endif
|
|
|
9389
|
|
|
9390 DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9391 {
|
|
|
9392 m_descriptorSetLayout = {};
|
|
|
9393 return *this;
|
|
|
9394 }
|
|
|
9395
|
|
|
9396 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
|
|
|
9397 {
|
|
|
9398 return m_descriptorSetLayout;
|
|
|
9399 }
|
|
|
9400
|
|
|
9401 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9402 {
|
|
|
9403 return m_descriptorSetLayout != VK_NULL_HANDLE;
|
|
|
9404 }
|
|
|
9405
|
|
|
9406 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9407 {
|
|
|
9408 return m_descriptorSetLayout == VK_NULL_HANDLE;
|
|
|
9409 }
|
|
|
9410
|
|
|
9411 private:
|
|
|
9412 VkDescriptorSetLayout m_descriptorSetLayout = {};
|
|
|
9413 };
|
|
|
9414
|
|
|
9415 template <>
|
|
|
9416 struct CppType<ObjectType, ObjectType::eDescriptorSetLayout>
|
|
|
9417 {
|
|
|
9418 using Type = DescriptorSetLayout;
|
|
|
9419 };
|
|
|
9420
|
|
|
9421 template <>
|
|
|
9422 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDescriptorSetLayout>
|
|
|
9423 {
|
|
|
9424 using Type = DescriptorSetLayout;
|
|
|
9425 };
|
|
|
9426
|
|
|
9427 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9428 template <>
|
|
|
9429 struct CppType<VkDescriptorSetLayout, VK_NULL_HANDLE>
|
|
|
9430 {
|
|
|
9431 using Type = DescriptorSetLayout;
|
|
|
9432 };
|
|
|
9433 #endif
|
|
|
9434
|
|
|
9435 template <>
|
|
|
9436 struct isVulkanHandleType<DescriptorSetLayout>
|
|
|
9437 {
|
|
|
9438 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9439 };
|
|
|
9440
|
|
|
9441 // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html
|
|
|
9442 class ExternalComputeQueueNV
|
|
|
9443 {
|
|
|
9444 public:
|
|
|
9445 using CType = VkExternalComputeQueueNV;
|
|
|
9446 using NativeType = VkExternalComputeQueueNV;
|
|
|
9447
|
|
|
9448 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eExternalComputeQueueNV;
|
|
|
9449 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
9450
|
|
|
9451 public:
|
|
|
9452 ExternalComputeQueueNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9453
|
|
|
9454 ExternalComputeQueueNV( ExternalComputeQueueNV const & rhs ) = default;
|
|
|
9455 ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & rhs ) = default;
|
|
|
9456
|
|
|
9457 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9458 ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) = default;
|
|
|
9459 ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) = default;
|
|
|
9460 #else
|
|
|
9461 ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( exchange( rhs.m_externalComputeQueueNV, {} ) ) {}
|
|
|
9462
|
|
|
9463 ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9464 {
|
|
|
9465 m_externalComputeQueueNV = exchange( rhs.m_externalComputeQueueNV, {} );
|
|
|
9466 return *this;
|
|
|
9467 }
|
|
|
9468 #endif
|
|
|
9469
|
|
|
9470 VULKAN_HPP_CONSTEXPR ExternalComputeQueueNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9471
|
|
|
9472 ExternalComputeQueueNV( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( externalComputeQueueNV ) {}
|
|
|
9473
|
|
|
9474 ExternalComputeQueueNV & operator=( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT
|
|
|
9475 {
|
|
|
9476 m_externalComputeQueueNV = externalComputeQueueNV;
|
|
|
9477 return *this;
|
|
|
9478 }
|
|
|
9479
|
|
|
9480 ExternalComputeQueueNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9481 {
|
|
|
9482 m_externalComputeQueueNV = {};
|
|
|
9483 return *this;
|
|
|
9484 }
|
|
|
9485
|
|
|
9486 //=== VK_NV_external_compute_queue ===
|
|
|
9487
|
|
|
9488 // wrapper function for command vkGetExternalComputeQueueDataNV, see
|
|
|
9489 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
|
|
|
9490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
9491 void
|
|
|
9492 getData( ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
9493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
9494 // wrapper function for command vkGetExternalComputeQueueDataNV, see
|
|
|
9495 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
|
|
|
9496 template <typename DataType,
|
|
|
9497 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
9498 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
9499 VULKAN_HPP_NODISCARD std::pair<ExternalComputeQueueDataParamsNV, DataType>
|
|
|
9500 getData( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
9501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
9502
|
|
|
9503 operator VkExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT
|
|
|
9504 {
|
|
|
9505 return m_externalComputeQueueNV;
|
|
|
9506 }
|
|
|
9507
|
|
|
9508 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9509 {
|
|
|
9510 return m_externalComputeQueueNV != VK_NULL_HANDLE;
|
|
|
9511 }
|
|
|
9512
|
|
|
9513 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9514 {
|
|
|
9515 return m_externalComputeQueueNV == VK_NULL_HANDLE;
|
|
|
9516 }
|
|
|
9517
|
|
|
9518 private:
|
|
|
9519 VkExternalComputeQueueNV m_externalComputeQueueNV = {};
|
|
|
9520 };
|
|
|
9521
|
|
|
9522 template <>
|
|
|
9523 struct CppType<ObjectType, ObjectType::eExternalComputeQueueNV>
|
|
|
9524 {
|
|
|
9525 using Type = ExternalComputeQueueNV;
|
|
|
9526 };
|
|
|
9527
|
|
|
9528 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9529 template <>
|
|
|
9530 struct CppType<VkExternalComputeQueueNV, VK_NULL_HANDLE>
|
|
|
9531 {
|
|
|
9532 using Type = ExternalComputeQueueNV;
|
|
|
9533 };
|
|
|
9534 #endif
|
|
|
9535
|
|
|
9536 template <>
|
|
|
9537 struct isVulkanHandleType<ExternalComputeQueueNV>
|
|
|
9538 {
|
|
|
9539 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9540 };
|
|
|
9541
|
|
|
9542 // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html
|
|
|
9543 class Framebuffer
|
|
|
9544 {
|
|
|
9545 public:
|
|
|
9546 using CType = VkFramebuffer;
|
|
|
9547 using NativeType = VkFramebuffer;
|
|
|
9548
|
|
|
9549 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer;
|
|
|
9550 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFramebuffer;
|
|
|
9551
|
|
|
9552 public:
|
|
|
9553 Framebuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9554
|
|
|
9555 Framebuffer( Framebuffer const & rhs ) = default;
|
|
|
9556 Framebuffer & operator=( Framebuffer const & rhs ) = default;
|
|
|
9557
|
|
|
9558 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9559 Framebuffer( Framebuffer && rhs ) = default;
|
|
|
9560 Framebuffer & operator=( Framebuffer && rhs ) = default;
|
|
|
9561 #else
|
|
|
9562 Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_framebuffer( exchange( rhs.m_framebuffer, {} ) ) {}
|
|
|
9563
|
|
|
9564 Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9565 {
|
|
|
9566 m_framebuffer = exchange( rhs.m_framebuffer, {} );
|
|
|
9567 return *this;
|
|
|
9568 }
|
|
|
9569 #endif
|
|
|
9570
|
|
|
9571 VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9572
|
|
|
9573 VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}
|
|
|
9574
|
|
|
9575 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9576 Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
|
|
|
9577 {
|
|
|
9578 m_framebuffer = framebuffer;
|
|
|
9579 return *this;
|
|
|
9580 }
|
|
|
9581 #endif
|
|
|
9582
|
|
|
9583 Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9584 {
|
|
|
9585 m_framebuffer = {};
|
|
|
9586 return *this;
|
|
|
9587 }
|
|
|
9588
|
|
|
9589 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
|
|
|
9590 {
|
|
|
9591 return m_framebuffer;
|
|
|
9592 }
|
|
|
9593
|
|
|
9594 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9595 {
|
|
|
9596 return m_framebuffer != VK_NULL_HANDLE;
|
|
|
9597 }
|
|
|
9598
|
|
|
9599 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9600 {
|
|
|
9601 return m_framebuffer == VK_NULL_HANDLE;
|
|
|
9602 }
|
|
|
9603
|
|
|
9604 private:
|
|
|
9605 VkFramebuffer m_framebuffer = {};
|
|
|
9606 };
|
|
|
9607
|
|
|
9608 template <>
|
|
|
9609 struct CppType<ObjectType, ObjectType::eFramebuffer>
|
|
|
9610 {
|
|
|
9611 using Type = Framebuffer;
|
|
|
9612 };
|
|
|
9613
|
|
|
9614 template <>
|
|
|
9615 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eFramebuffer>
|
|
|
9616 {
|
|
|
9617 using Type = Framebuffer;
|
|
|
9618 };
|
|
|
9619
|
|
|
9620 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9621 template <>
|
|
|
9622 struct CppType<VkFramebuffer, VK_NULL_HANDLE>
|
|
|
9623 {
|
|
|
9624 using Type = Framebuffer;
|
|
|
9625 };
|
|
|
9626 #endif
|
|
|
9627
|
|
|
9628 template <>
|
|
|
9629 struct isVulkanHandleType<Framebuffer>
|
|
|
9630 {
|
|
|
9631 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9632 };
|
|
|
9633
|
|
|
9634 // wrapper class for handle VkIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutEXT.html
|
|
|
9635 class IndirectCommandsLayoutEXT
|
|
|
9636 {
|
|
|
9637 public:
|
|
|
9638 using CType = VkIndirectCommandsLayoutEXT;
|
|
|
9639 using NativeType = VkIndirectCommandsLayoutEXT;
|
|
|
9640
|
|
|
9641 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutEXT;
|
|
|
9642 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
9643
|
|
|
9644 public:
|
|
|
9645 IndirectCommandsLayoutEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9646
|
|
|
9647 IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT const & rhs ) = default;
|
|
|
9648 IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT const & rhs ) = default;
|
|
|
9649
|
|
|
9650 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9651 IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) = default;
|
|
|
9652 IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) = default;
|
|
|
9653 #else
|
|
|
9654 IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9655 : m_indirectCommandsLayoutEXT( exchange( rhs.m_indirectCommandsLayoutEXT, {} ) )
|
|
|
9656 {
|
|
|
9657 }
|
|
|
9658
|
|
|
9659 IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9660 {
|
|
|
9661 m_indirectCommandsLayoutEXT = exchange( rhs.m_indirectCommandsLayoutEXT, {} );
|
|
|
9662 return *this;
|
|
|
9663 }
|
|
|
9664 #endif
|
|
|
9665
|
|
|
9666 VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9667
|
|
|
9668 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutEXT( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
9669 : m_indirectCommandsLayoutEXT( indirectCommandsLayoutEXT )
|
|
|
9670 {
|
|
|
9671 }
|
|
|
9672
|
|
|
9673 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9674 IndirectCommandsLayoutEXT & operator=( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
9675 {
|
|
|
9676 m_indirectCommandsLayoutEXT = indirectCommandsLayoutEXT;
|
|
|
9677 return *this;
|
|
|
9678 }
|
|
|
9679 #endif
|
|
|
9680
|
|
|
9681 IndirectCommandsLayoutEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9682 {
|
|
|
9683 m_indirectCommandsLayoutEXT = {};
|
|
|
9684 return *this;
|
|
|
9685 }
|
|
|
9686
|
|
|
9687 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT
|
|
|
9688 {
|
|
|
9689 return m_indirectCommandsLayoutEXT;
|
|
|
9690 }
|
|
|
9691
|
|
|
9692 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9693 {
|
|
|
9694 return m_indirectCommandsLayoutEXT != VK_NULL_HANDLE;
|
|
|
9695 }
|
|
|
9696
|
|
|
9697 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9698 {
|
|
|
9699 return m_indirectCommandsLayoutEXT == VK_NULL_HANDLE;
|
|
|
9700 }
|
|
|
9701
|
|
|
9702 private:
|
|
|
9703 VkIndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {};
|
|
|
9704 };
|
|
|
9705
|
|
|
9706 template <>
|
|
|
9707 struct CppType<ObjectType, ObjectType::eIndirectCommandsLayoutEXT>
|
|
|
9708 {
|
|
|
9709 using Type = IndirectCommandsLayoutEXT;
|
|
|
9710 };
|
|
|
9711
|
|
|
9712 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9713 template <>
|
|
|
9714 struct CppType<VkIndirectCommandsLayoutEXT, VK_NULL_HANDLE>
|
|
|
9715 {
|
|
|
9716 using Type = IndirectCommandsLayoutEXT;
|
|
|
9717 };
|
|
|
9718 #endif
|
|
|
9719
|
|
|
9720 template <>
|
|
|
9721 struct isVulkanHandleType<IndirectCommandsLayoutEXT>
|
|
|
9722 {
|
|
|
9723 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9724 };
|
|
|
9725
|
|
|
9726 // wrapper class for handle VkIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutNV.html
|
|
|
9727 class IndirectCommandsLayoutNV
|
|
|
9728 {
|
|
|
9729 public:
|
|
|
9730 using CType = VkIndirectCommandsLayoutNV;
|
|
|
9731 using NativeType = VkIndirectCommandsLayoutNV;
|
|
|
9732
|
|
|
9733 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNV;
|
|
|
9734 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
9735
|
|
|
9736 public:
|
|
|
9737 IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9738
|
|
|
9739 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs ) = default;
|
|
|
9740 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default;
|
|
|
9741
|
|
|
9742 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9743 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) = default;
|
|
|
9744 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default;
|
|
|
9745 #else
|
|
|
9746 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9747 : m_indirectCommandsLayoutNV( exchange( rhs.m_indirectCommandsLayoutNV, {} ) )
|
|
|
9748 {
|
|
|
9749 }
|
|
|
9750
|
|
|
9751 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9752 {
|
|
|
9753 m_indirectCommandsLayoutNV = exchange( rhs.m_indirectCommandsLayoutNV, {} );
|
|
|
9754 return *this;
|
|
|
9755 }
|
|
|
9756 #endif
|
|
|
9757
|
|
|
9758 VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9759
|
|
|
9760 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
|
|
|
9761 : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
|
|
|
9762 {
|
|
|
9763 }
|
|
|
9764
|
|
|
9765 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9766 IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
|
|
|
9767 {
|
|
|
9768 m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
|
|
|
9769 return *this;
|
|
|
9770 }
|
|
|
9771 #endif
|
|
|
9772
|
|
|
9773 IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9774 {
|
|
|
9775 m_indirectCommandsLayoutNV = {};
|
|
|
9776 return *this;
|
|
|
9777 }
|
|
|
9778
|
|
|
9779 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
|
|
|
9780 {
|
|
|
9781 return m_indirectCommandsLayoutNV;
|
|
|
9782 }
|
|
|
9783
|
|
|
9784 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9785 {
|
|
|
9786 return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
|
|
|
9787 }
|
|
|
9788
|
|
|
9789 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9790 {
|
|
|
9791 return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
|
|
|
9792 }
|
|
|
9793
|
|
|
9794 private:
|
|
|
9795 VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
|
|
|
9796 };
|
|
|
9797
|
|
|
9798 template <>
|
|
|
9799 struct CppType<ObjectType, ObjectType::eIndirectCommandsLayoutNV>
|
|
|
9800 {
|
|
|
9801 using Type = IndirectCommandsLayoutNV;
|
|
|
9802 };
|
|
|
9803
|
|
|
9804 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9805 template <>
|
|
|
9806 struct CppType<VkIndirectCommandsLayoutNV, VK_NULL_HANDLE>
|
|
|
9807 {
|
|
|
9808 using Type = IndirectCommandsLayoutNV;
|
|
|
9809 };
|
|
|
9810 #endif
|
|
|
9811
|
|
|
9812 template <>
|
|
|
9813 struct isVulkanHandleType<IndirectCommandsLayoutNV>
|
|
|
9814 {
|
|
|
9815 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9816 };
|
|
|
9817
|
|
|
9818 // wrapper class for handle VkIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetEXT.html
|
|
|
9819 class IndirectExecutionSetEXT
|
|
|
9820 {
|
|
|
9821 public:
|
|
|
9822 using CType = VkIndirectExecutionSetEXT;
|
|
|
9823 using NativeType = VkIndirectExecutionSetEXT;
|
|
|
9824
|
|
|
9825 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectExecutionSetEXT;
|
|
|
9826 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
9827
|
|
|
9828 public:
|
|
|
9829 IndirectExecutionSetEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9830
|
|
|
9831 IndirectExecutionSetEXT( IndirectExecutionSetEXT const & rhs ) = default;
|
|
|
9832 IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT const & rhs ) = default;
|
|
|
9833
|
|
|
9834 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9835 IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) = default;
|
|
|
9836 IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) = default;
|
|
|
9837 #else
|
|
|
9838 IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_indirectExecutionSetEXT( exchange( rhs.m_indirectExecutionSetEXT, {} ) )
|
|
|
9839 {
|
|
|
9840 }
|
|
|
9841
|
|
|
9842 IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9843 {
|
|
|
9844 m_indirectExecutionSetEXT = exchange( rhs.m_indirectExecutionSetEXT, {} );
|
|
|
9845 return *this;
|
|
|
9846 }
|
|
|
9847 #endif
|
|
|
9848
|
|
|
9849 VULKAN_HPP_CONSTEXPR IndirectExecutionSetEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9850
|
|
|
9851 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectExecutionSetEXT( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
9852 : m_indirectExecutionSetEXT( indirectExecutionSetEXT )
|
|
|
9853 {
|
|
|
9854 }
|
|
|
9855
|
|
|
9856 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9857 IndirectExecutionSetEXT & operator=( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
9858 {
|
|
|
9859 m_indirectExecutionSetEXT = indirectExecutionSetEXT;
|
|
|
9860 return *this;
|
|
|
9861 }
|
|
|
9862 #endif
|
|
|
9863
|
|
|
9864 IndirectExecutionSetEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9865 {
|
|
|
9866 m_indirectExecutionSetEXT = {};
|
|
|
9867 return *this;
|
|
|
9868 }
|
|
|
9869
|
|
|
9870 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT
|
|
|
9871 {
|
|
|
9872 return m_indirectExecutionSetEXT;
|
|
|
9873 }
|
|
|
9874
|
|
|
9875 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9876 {
|
|
|
9877 return m_indirectExecutionSetEXT != VK_NULL_HANDLE;
|
|
|
9878 }
|
|
|
9879
|
|
|
9880 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9881 {
|
|
|
9882 return m_indirectExecutionSetEXT == VK_NULL_HANDLE;
|
|
|
9883 }
|
|
|
9884
|
|
|
9885 private:
|
|
|
9886 VkIndirectExecutionSetEXT m_indirectExecutionSetEXT = {};
|
|
|
9887 };
|
|
|
9888
|
|
|
9889 template <>
|
|
|
9890 struct CppType<ObjectType, ObjectType::eIndirectExecutionSetEXT>
|
|
|
9891 {
|
|
|
9892 using Type = IndirectExecutionSetEXT;
|
|
|
9893 };
|
|
|
9894
|
|
|
9895 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9896 template <>
|
|
|
9897 struct CppType<VkIndirectExecutionSetEXT, VK_NULL_HANDLE>
|
|
|
9898 {
|
|
|
9899 using Type = IndirectExecutionSetEXT;
|
|
|
9900 };
|
|
|
9901 #endif
|
|
|
9902
|
|
|
9903 template <>
|
|
|
9904 struct isVulkanHandleType<IndirectExecutionSetEXT>
|
|
|
9905 {
|
|
|
9906 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9907 };
|
|
|
9908
|
|
|
9909 // wrapper class for handle VkPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlot.html
|
|
|
9910 class PrivateDataSlot
|
|
|
9911 {
|
|
|
9912 public:
|
|
|
9913 using CType = VkPrivateDataSlot;
|
|
|
9914 using NativeType = VkPrivateDataSlot;
|
|
|
9915
|
|
|
9916 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePrivateDataSlot;
|
|
|
9917 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
9918
|
|
|
9919 public:
|
|
|
9920 PrivateDataSlot() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
9921
|
|
|
9922 PrivateDataSlot( PrivateDataSlot const & rhs ) = default;
|
|
|
9923 PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;
|
|
|
9924
|
|
|
9925 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
9926 PrivateDataSlot( PrivateDataSlot && rhs ) = default;
|
|
|
9927 PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default;
|
|
|
9928 #else
|
|
|
9929 PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( exchange( rhs.m_privateDataSlot, {} ) ) {}
|
|
|
9930
|
|
|
9931 PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
9932 {
|
|
|
9933 m_privateDataSlot = exchange( rhs.m_privateDataSlot, {} );
|
|
|
9934 return *this;
|
|
|
9935 }
|
|
|
9936 #endif
|
|
|
9937
|
|
|
9938 VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
9939
|
|
|
9940 VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
|
|
|
9941
|
|
|
9942 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
9943 PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
|
|
|
9944 {
|
|
|
9945 m_privateDataSlot = privateDataSlot;
|
|
|
9946 return *this;
|
|
|
9947 }
|
|
|
9948 #endif
|
|
|
9949
|
|
|
9950 PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
9951 {
|
|
|
9952 m_privateDataSlot = {};
|
|
|
9953 return *this;
|
|
|
9954 }
|
|
|
9955
|
|
|
9956 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
|
|
|
9957 {
|
|
|
9958 return m_privateDataSlot;
|
|
|
9959 }
|
|
|
9960
|
|
|
9961 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
9962 {
|
|
|
9963 return m_privateDataSlot != VK_NULL_HANDLE;
|
|
|
9964 }
|
|
|
9965
|
|
|
9966 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
9967 {
|
|
|
9968 return m_privateDataSlot == VK_NULL_HANDLE;
|
|
|
9969 }
|
|
|
9970
|
|
|
9971 private:
|
|
|
9972 VkPrivateDataSlot m_privateDataSlot = {};
|
|
|
9973 };
|
|
|
9974
|
|
|
9975 template <>
|
|
|
9976 struct CppType<ObjectType, ObjectType::ePrivateDataSlot>
|
|
|
9977 {
|
|
|
9978 using Type = PrivateDataSlot;
|
|
|
9979 };
|
|
|
9980
|
|
|
9981 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
9982 template <>
|
|
|
9983 struct CppType<VkPrivateDataSlot, VK_NULL_HANDLE>
|
|
|
9984 {
|
|
|
9985 using Type = PrivateDataSlot;
|
|
|
9986 };
|
|
|
9987 #endif
|
|
|
9988
|
|
|
9989 template <>
|
|
|
9990 struct isVulkanHandleType<PrivateDataSlot>
|
|
|
9991 {
|
|
|
9992 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
9993 };
|
|
|
9994
|
|
|
9995 using PrivateDataSlotEXT = PrivateDataSlot;
|
|
|
9996
|
|
|
9997 // wrapper class for handle VkRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPass.html
|
|
|
9998 class RenderPass
|
|
|
9999 {
|
|
|
10000 public:
|
|
|
10001 using CType = VkRenderPass;
|
|
|
10002 using NativeType = VkRenderPass;
|
|
|
10003
|
|
|
10004 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass;
|
|
|
10005 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eRenderPass;
|
|
|
10006
|
|
|
10007 public:
|
|
|
10008 RenderPass() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10009
|
|
|
10010 RenderPass( RenderPass const & rhs ) = default;
|
|
|
10011 RenderPass & operator=( RenderPass const & rhs ) = default;
|
|
|
10012
|
|
|
10013 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10014 RenderPass( RenderPass && rhs ) = default;
|
|
|
10015 RenderPass & operator=( RenderPass && rhs ) = default;
|
|
|
10016 #else
|
|
|
10017 RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT : m_renderPass( exchange( rhs.m_renderPass, {} ) ) {}
|
|
|
10018
|
|
|
10019 RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10020 {
|
|
|
10021 m_renderPass = exchange( rhs.m_renderPass, {} );
|
|
|
10022 return *this;
|
|
|
10023 }
|
|
|
10024 #endif
|
|
|
10025
|
|
|
10026 VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10027
|
|
|
10028 VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
|
|
|
10029
|
|
|
10030 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10031 RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
|
|
|
10032 {
|
|
|
10033 m_renderPass = renderPass;
|
|
|
10034 return *this;
|
|
|
10035 }
|
|
|
10036 #endif
|
|
|
10037
|
|
|
10038 RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10039 {
|
|
|
10040 m_renderPass = {};
|
|
|
10041 return *this;
|
|
|
10042 }
|
|
|
10043
|
|
|
10044 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
|
|
|
10045 {
|
|
|
10046 return m_renderPass;
|
|
|
10047 }
|
|
|
10048
|
|
|
10049 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10050 {
|
|
|
10051 return m_renderPass != VK_NULL_HANDLE;
|
|
|
10052 }
|
|
|
10053
|
|
|
10054 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10055 {
|
|
|
10056 return m_renderPass == VK_NULL_HANDLE;
|
|
|
10057 }
|
|
|
10058
|
|
|
10059 private:
|
|
|
10060 VkRenderPass m_renderPass = {};
|
|
|
10061 };
|
|
|
10062
|
|
|
10063 template <>
|
|
|
10064 struct CppType<ObjectType, ObjectType::eRenderPass>
|
|
|
10065 {
|
|
|
10066 using Type = RenderPass;
|
|
|
10067 };
|
|
|
10068
|
|
|
10069 template <>
|
|
|
10070 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eRenderPass>
|
|
|
10071 {
|
|
|
10072 using Type = RenderPass;
|
|
|
10073 };
|
|
|
10074
|
|
|
10075 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10076 template <>
|
|
|
10077 struct CppType<VkRenderPass, VK_NULL_HANDLE>
|
|
|
10078 {
|
|
|
10079 using Type = RenderPass;
|
|
|
10080 };
|
|
|
10081 #endif
|
|
|
10082
|
|
|
10083 template <>
|
|
|
10084 struct isVulkanHandleType<RenderPass>
|
|
|
10085 {
|
|
|
10086 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10087 };
|
|
|
10088
|
|
|
10089 // wrapper class for handle VkSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampler.html
|
|
|
10090 class Sampler
|
|
|
10091 {
|
|
|
10092 public:
|
|
|
10093 using CType = VkSampler;
|
|
|
10094 using NativeType = VkSampler;
|
|
|
10095
|
|
|
10096 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler;
|
|
|
10097 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSampler;
|
|
|
10098
|
|
|
10099 public:
|
|
|
10100 Sampler() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10101
|
|
|
10102 Sampler( Sampler const & rhs ) = default;
|
|
|
10103 Sampler & operator=( Sampler const & rhs ) = default;
|
|
|
10104
|
|
|
10105 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10106 Sampler( Sampler && rhs ) = default;
|
|
|
10107 Sampler & operator=( Sampler && rhs ) = default;
|
|
|
10108 #else
|
|
|
10109 Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT : m_sampler( exchange( rhs.m_sampler, {} ) ) {}
|
|
|
10110
|
|
|
10111 Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10112 {
|
|
|
10113 m_sampler = exchange( rhs.m_sampler, {} );
|
|
|
10114 return *this;
|
|
|
10115 }
|
|
|
10116 #endif
|
|
|
10117
|
|
|
10118 VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10119
|
|
|
10120 VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
|
|
|
10121
|
|
|
10122 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10123 Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
|
|
|
10124 {
|
|
|
10125 m_sampler = sampler;
|
|
|
10126 return *this;
|
|
|
10127 }
|
|
|
10128 #endif
|
|
|
10129
|
|
|
10130 Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10131 {
|
|
|
10132 m_sampler = {};
|
|
|
10133 return *this;
|
|
|
10134 }
|
|
|
10135
|
|
|
10136 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
|
|
|
10137 {
|
|
|
10138 return m_sampler;
|
|
|
10139 }
|
|
|
10140
|
|
|
10141 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10142 {
|
|
|
10143 return m_sampler != VK_NULL_HANDLE;
|
|
|
10144 }
|
|
|
10145
|
|
|
10146 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10147 {
|
|
|
10148 return m_sampler == VK_NULL_HANDLE;
|
|
|
10149 }
|
|
|
10150
|
|
|
10151 private:
|
|
|
10152 VkSampler m_sampler = {};
|
|
|
10153 };
|
|
|
10154
|
|
|
10155 template <>
|
|
|
10156 struct CppType<ObjectType, ObjectType::eSampler>
|
|
|
10157 {
|
|
|
10158 using Type = Sampler;
|
|
|
10159 };
|
|
|
10160
|
|
|
10161 template <>
|
|
|
10162 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSampler>
|
|
|
10163 {
|
|
|
10164 using Type = Sampler;
|
|
|
10165 };
|
|
|
10166
|
|
|
10167 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10168 template <>
|
|
|
10169 struct CppType<VkSampler, VK_NULL_HANDLE>
|
|
|
10170 {
|
|
|
10171 using Type = Sampler;
|
|
|
10172 };
|
|
|
10173 #endif
|
|
|
10174
|
|
|
10175 template <>
|
|
|
10176 struct isVulkanHandleType<Sampler>
|
|
|
10177 {
|
|
|
10178 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10179 };
|
|
|
10180
|
|
|
10181 // wrapper class for handle VkSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversion.html
|
|
|
10182 class SamplerYcbcrConversion
|
|
|
10183 {
|
|
|
10184 public:
|
|
|
10185 using CType = VkSamplerYcbcrConversion;
|
|
|
10186 using NativeType = VkSamplerYcbcrConversion;
|
|
|
10187
|
|
|
10188 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion;
|
|
|
10189 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
|
|
|
10190
|
|
|
10191 public:
|
|
|
10192 SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10193
|
|
|
10194 SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default;
|
|
|
10195 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;
|
|
|
10196
|
|
|
10197 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10198 SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default;
|
|
|
10199 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default;
|
|
|
10200 #else
|
|
|
10201 SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( exchange( rhs.m_samplerYcbcrConversion, {} ) ) {}
|
|
|
10202
|
|
|
10203 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10204 {
|
|
|
10205 m_samplerYcbcrConversion = exchange( rhs.m_samplerYcbcrConversion, {} );
|
|
|
10206 return *this;
|
|
|
10207 }
|
|
|
10208 #endif
|
|
|
10209
|
|
|
10210 VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10211
|
|
|
10212 VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
|
|
|
10213 : m_samplerYcbcrConversion( samplerYcbcrConversion )
|
|
|
10214 {
|
|
|
10215 }
|
|
|
10216
|
|
|
10217 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10218 SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
|
|
|
10219 {
|
|
|
10220 m_samplerYcbcrConversion = samplerYcbcrConversion;
|
|
|
10221 return *this;
|
|
|
10222 }
|
|
|
10223 #endif
|
|
|
10224
|
|
|
10225 SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10226 {
|
|
|
10227 m_samplerYcbcrConversion = {};
|
|
|
10228 return *this;
|
|
|
10229 }
|
|
|
10230
|
|
|
10231 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
|
|
|
10232 {
|
|
|
10233 return m_samplerYcbcrConversion;
|
|
|
10234 }
|
|
|
10235
|
|
|
10236 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10237 {
|
|
|
10238 return m_samplerYcbcrConversion != VK_NULL_HANDLE;
|
|
|
10239 }
|
|
|
10240
|
|
|
10241 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10242 {
|
|
|
10243 return m_samplerYcbcrConversion == VK_NULL_HANDLE;
|
|
|
10244 }
|
|
|
10245
|
|
|
10246 private:
|
|
|
10247 VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
|
|
|
10248 };
|
|
|
10249
|
|
|
10250 template <>
|
|
|
10251 struct CppType<ObjectType, ObjectType::eSamplerYcbcrConversion>
|
|
|
10252 {
|
|
|
10253 using Type = SamplerYcbcrConversion;
|
|
|
10254 };
|
|
|
10255
|
|
|
10256 template <>
|
|
|
10257 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
|
|
|
10258 {
|
|
|
10259 using Type = SamplerYcbcrConversion;
|
|
|
10260 };
|
|
|
10261
|
|
|
10262 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10263 template <>
|
|
|
10264 struct CppType<VkSamplerYcbcrConversion, VK_NULL_HANDLE>
|
|
|
10265 {
|
|
|
10266 using Type = SamplerYcbcrConversion;
|
|
|
10267 };
|
|
|
10268 #endif
|
|
|
10269
|
|
|
10270 template <>
|
|
|
10271 struct isVulkanHandleType<SamplerYcbcrConversion>
|
|
|
10272 {
|
|
|
10273 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10274 };
|
|
|
10275
|
|
|
10276 using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
|
|
|
10277
|
|
|
10278 // wrapper class for handle VkShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModule.html
|
|
|
10279 class ShaderModule
|
|
|
10280 {
|
|
|
10281 public:
|
|
|
10282 using CType = VkShaderModule;
|
|
|
10283 using NativeType = VkShaderModule;
|
|
|
10284
|
|
|
10285 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule;
|
|
|
10286 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eShaderModule;
|
|
|
10287
|
|
|
10288 public:
|
|
|
10289 ShaderModule() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10290
|
|
|
10291 ShaderModule( ShaderModule const & rhs ) = default;
|
|
|
10292 ShaderModule & operator=( ShaderModule const & rhs ) = default;
|
|
|
10293
|
|
|
10294 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10295 ShaderModule( ShaderModule && rhs ) = default;
|
|
|
10296 ShaderModule & operator=( ShaderModule && rhs ) = default;
|
|
|
10297 #else
|
|
|
10298 ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderModule( exchange( rhs.m_shaderModule, {} ) ) {}
|
|
|
10299
|
|
|
10300 ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10301 {
|
|
|
10302 m_shaderModule = exchange( rhs.m_shaderModule, {} );
|
|
|
10303 return *this;
|
|
|
10304 }
|
|
|
10305 #endif
|
|
|
10306
|
|
|
10307 VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10308
|
|
|
10309 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
|
|
|
10310
|
|
|
10311 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10312 ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
|
|
|
10313 {
|
|
|
10314 m_shaderModule = shaderModule;
|
|
|
10315 return *this;
|
|
|
10316 }
|
|
|
10317 #endif
|
|
|
10318
|
|
|
10319 ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10320 {
|
|
|
10321 m_shaderModule = {};
|
|
|
10322 return *this;
|
|
|
10323 }
|
|
|
10324
|
|
|
10325 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
|
|
|
10326 {
|
|
|
10327 return m_shaderModule;
|
|
|
10328 }
|
|
|
10329
|
|
|
10330 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10331 {
|
|
|
10332 return m_shaderModule != VK_NULL_HANDLE;
|
|
|
10333 }
|
|
|
10334
|
|
|
10335 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10336 {
|
|
|
10337 return m_shaderModule == VK_NULL_HANDLE;
|
|
|
10338 }
|
|
|
10339
|
|
|
10340 private:
|
|
|
10341 VkShaderModule m_shaderModule = {};
|
|
|
10342 };
|
|
|
10343
|
|
|
10344 template <>
|
|
|
10345 struct CppType<ObjectType, ObjectType::eShaderModule>
|
|
|
10346 {
|
|
|
10347 using Type = ShaderModule;
|
|
|
10348 };
|
|
|
10349
|
|
|
10350 template <>
|
|
|
10351 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eShaderModule>
|
|
|
10352 {
|
|
|
10353 using Type = ShaderModule;
|
|
|
10354 };
|
|
|
10355
|
|
|
10356 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10357 template <>
|
|
|
10358 struct CppType<VkShaderModule, VK_NULL_HANDLE>
|
|
|
10359 {
|
|
|
10360 using Type = ShaderModule;
|
|
|
10361 };
|
|
|
10362 #endif
|
|
|
10363
|
|
|
10364 template <>
|
|
|
10365 struct isVulkanHandleType<ShaderModule>
|
|
|
10366 {
|
|
|
10367 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10368 };
|
|
|
10369
|
|
|
10370 // wrapper class for handle VkTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorARM.html
|
|
|
10371 class TensorARM
|
|
|
10372 {
|
|
|
10373 public:
|
|
|
10374 using CType = VkTensorARM;
|
|
|
10375 using NativeType = VkTensorARM;
|
|
|
10376
|
|
|
10377 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorARM;
|
|
|
10378 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
10379
|
|
|
10380 public:
|
|
|
10381 TensorARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10382
|
|
|
10383 TensorARM( TensorARM const & rhs ) = default;
|
|
|
10384 TensorARM & operator=( TensorARM const & rhs ) = default;
|
|
|
10385
|
|
|
10386 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10387 TensorARM( TensorARM && rhs ) = default;
|
|
|
10388 TensorARM & operator=( TensorARM && rhs ) = default;
|
|
|
10389 #else
|
|
|
10390 TensorARM( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorARM( exchange( rhs.m_tensorARM, {} ) ) {}
|
|
|
10391
|
|
|
10392 TensorARM & operator=( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10393 {
|
|
|
10394 m_tensorARM = exchange( rhs.m_tensorARM, {} );
|
|
|
10395 return *this;
|
|
|
10396 }
|
|
|
10397 #endif
|
|
|
10398
|
|
|
10399 VULKAN_HPP_CONSTEXPR TensorARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10400
|
|
|
10401 VULKAN_HPP_TYPESAFE_EXPLICIT TensorARM( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT : m_tensorARM( tensorARM ) {}
|
|
|
10402
|
|
|
10403 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10404 TensorARM & operator=( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT
|
|
|
10405 {
|
|
|
10406 m_tensorARM = tensorARM;
|
|
|
10407 return *this;
|
|
|
10408 }
|
|
|
10409 #endif
|
|
|
10410
|
|
|
10411 TensorARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10412 {
|
|
|
10413 m_tensorARM = {};
|
|
|
10414 return *this;
|
|
|
10415 }
|
|
|
10416
|
|
|
10417 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorARM() const VULKAN_HPP_NOEXCEPT
|
|
|
10418 {
|
|
|
10419 return m_tensorARM;
|
|
|
10420 }
|
|
|
10421
|
|
|
10422 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10423 {
|
|
|
10424 return m_tensorARM != VK_NULL_HANDLE;
|
|
|
10425 }
|
|
|
10426
|
|
|
10427 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10428 {
|
|
|
10429 return m_tensorARM == VK_NULL_HANDLE;
|
|
|
10430 }
|
|
|
10431
|
|
|
10432 private:
|
|
|
10433 VkTensorARM m_tensorARM = {};
|
|
|
10434 };
|
|
|
10435
|
|
|
10436 template <>
|
|
|
10437 struct CppType<ObjectType, ObjectType::eTensorARM>
|
|
|
10438 {
|
|
|
10439 using Type = TensorARM;
|
|
|
10440 };
|
|
|
10441
|
|
|
10442 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10443 template <>
|
|
|
10444 struct CppType<VkTensorARM, VK_NULL_HANDLE>
|
|
|
10445 {
|
|
|
10446 using Type = TensorARM;
|
|
|
10447 };
|
|
|
10448 #endif
|
|
|
10449
|
|
|
10450 template <>
|
|
|
10451 struct isVulkanHandleType<TensorARM>
|
|
|
10452 {
|
|
|
10453 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10454 };
|
|
|
10455
|
|
|
10456 // wrapper class for handle VkTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewARM.html
|
|
|
10457 class TensorViewARM
|
|
|
10458 {
|
|
|
10459 public:
|
|
|
10460 using CType = VkTensorViewARM;
|
|
|
10461 using NativeType = VkTensorViewARM;
|
|
|
10462
|
|
|
10463 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorViewARM;
|
|
|
10464 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
10465
|
|
|
10466 public:
|
|
|
10467 TensorViewARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10468
|
|
|
10469 TensorViewARM( TensorViewARM const & rhs ) = default;
|
|
|
10470 TensorViewARM & operator=( TensorViewARM const & rhs ) = default;
|
|
|
10471
|
|
|
10472 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10473 TensorViewARM( TensorViewARM && rhs ) = default;
|
|
|
10474 TensorViewARM & operator=( TensorViewARM && rhs ) = default;
|
|
|
10475 #else
|
|
|
10476 TensorViewARM( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( exchange( rhs.m_tensorViewARM, {} ) ) {}
|
|
|
10477
|
|
|
10478 TensorViewARM & operator=( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10479 {
|
|
|
10480 m_tensorViewARM = exchange( rhs.m_tensorViewARM, {} );
|
|
|
10481 return *this;
|
|
|
10482 }
|
|
|
10483 #endif
|
|
|
10484
|
|
|
10485 VULKAN_HPP_CONSTEXPR TensorViewARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10486
|
|
|
10487 VULKAN_HPP_TYPESAFE_EXPLICIT TensorViewARM( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( tensorViewARM ) {}
|
|
|
10488
|
|
|
10489 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10490 TensorViewARM & operator=( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT
|
|
|
10491 {
|
|
|
10492 m_tensorViewARM = tensorViewARM;
|
|
|
10493 return *this;
|
|
|
10494 }
|
|
|
10495 #endif
|
|
|
10496
|
|
|
10497 TensorViewARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10498 {
|
|
|
10499 m_tensorViewARM = {};
|
|
|
10500 return *this;
|
|
|
10501 }
|
|
|
10502
|
|
|
10503 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorViewARM() const VULKAN_HPP_NOEXCEPT
|
|
|
10504 {
|
|
|
10505 return m_tensorViewARM;
|
|
|
10506 }
|
|
|
10507
|
|
|
10508 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10509 {
|
|
|
10510 return m_tensorViewARM != VK_NULL_HANDLE;
|
|
|
10511 }
|
|
|
10512
|
|
|
10513 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10514 {
|
|
|
10515 return m_tensorViewARM == VK_NULL_HANDLE;
|
|
|
10516 }
|
|
|
10517
|
|
|
10518 private:
|
|
|
10519 VkTensorViewARM m_tensorViewARM = {};
|
|
|
10520 };
|
|
|
10521
|
|
|
10522 template <>
|
|
|
10523 struct CppType<ObjectType, ObjectType::eTensorViewARM>
|
|
|
10524 {
|
|
|
10525 using Type = TensorViewARM;
|
|
|
10526 };
|
|
|
10527
|
|
|
10528 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10529 template <>
|
|
|
10530 struct CppType<VkTensorViewARM, VK_NULL_HANDLE>
|
|
|
10531 {
|
|
|
10532 using Type = TensorViewARM;
|
|
|
10533 };
|
|
|
10534 #endif
|
|
|
10535
|
|
|
10536 template <>
|
|
|
10537 struct isVulkanHandleType<TensorViewARM>
|
|
|
10538 {
|
|
|
10539 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10540 };
|
|
|
10541
|
|
|
10542 // wrapper class for handle VkValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheEXT.html
|
|
|
10543 class ValidationCacheEXT
|
|
|
10544 {
|
|
|
10545 public:
|
|
|
10546 using CType = VkValidationCacheEXT;
|
|
|
10547 using NativeType = VkValidationCacheEXT;
|
|
|
10548
|
|
|
10549 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT;
|
|
|
10550 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eValidationCacheEXT;
|
|
|
10551
|
|
|
10552 public:
|
|
|
10553 ValidationCacheEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10554
|
|
|
10555 ValidationCacheEXT( ValidationCacheEXT const & rhs ) = default;
|
|
|
10556 ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default;
|
|
|
10557
|
|
|
10558 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10559 ValidationCacheEXT( ValidationCacheEXT && rhs ) = default;
|
|
|
10560 ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default;
|
|
|
10561 #else
|
|
|
10562 ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( exchange( rhs.m_validationCacheEXT, {} ) ) {}
|
|
|
10563
|
|
|
10564 ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10565 {
|
|
|
10566 m_validationCacheEXT = exchange( rhs.m_validationCacheEXT, {} );
|
|
|
10567 return *this;
|
|
|
10568 }
|
|
|
10569 #endif
|
|
|
10570
|
|
|
10571 VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10572
|
|
|
10573 VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
|
|
|
10574 {
|
|
|
10575 }
|
|
|
10576
|
|
|
10577 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10578 ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
|
|
|
10579 {
|
|
|
10580 m_validationCacheEXT = validationCacheEXT;
|
|
|
10581 return *this;
|
|
|
10582 }
|
|
|
10583 #endif
|
|
|
10584
|
|
|
10585 ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10586 {
|
|
|
10587 m_validationCacheEXT = {};
|
|
|
10588 return *this;
|
|
|
10589 }
|
|
|
10590
|
|
|
10591 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
|
|
|
10592 {
|
|
|
10593 return m_validationCacheEXT;
|
|
|
10594 }
|
|
|
10595
|
|
|
10596 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10597 {
|
|
|
10598 return m_validationCacheEXT != VK_NULL_HANDLE;
|
|
|
10599 }
|
|
|
10600
|
|
|
10601 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10602 {
|
|
|
10603 return m_validationCacheEXT == VK_NULL_HANDLE;
|
|
|
10604 }
|
|
|
10605
|
|
|
10606 private:
|
|
|
10607 VkValidationCacheEXT m_validationCacheEXT = {};
|
|
|
10608 };
|
|
|
10609
|
|
|
10610 template <>
|
|
|
10611 struct CppType<ObjectType, ObjectType::eValidationCacheEXT>
|
|
|
10612 {
|
|
|
10613 using Type = ValidationCacheEXT;
|
|
|
10614 };
|
|
|
10615
|
|
|
10616 template <>
|
|
|
10617 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eValidationCacheEXT>
|
|
|
10618 {
|
|
|
10619 using Type = ValidationCacheEXT;
|
|
|
10620 };
|
|
|
10621
|
|
|
10622 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10623 template <>
|
|
|
10624 struct CppType<VkValidationCacheEXT, VK_NULL_HANDLE>
|
|
|
10625 {
|
|
|
10626 using Type = ValidationCacheEXT;
|
|
|
10627 };
|
|
|
10628 #endif
|
|
|
10629
|
|
|
10630 template <>
|
|
|
10631 struct isVulkanHandleType<ValidationCacheEXT>
|
|
|
10632 {
|
|
|
10633 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10634 };
|
|
|
10635
|
|
|
10636 // wrapper class for handle VkVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersKHR.html
|
|
|
10637 class VideoSessionParametersKHR
|
|
|
10638 {
|
|
|
10639 public:
|
|
|
10640 using CType = VkVideoSessionParametersKHR;
|
|
|
10641 using NativeType = VkVideoSessionParametersKHR;
|
|
|
10642
|
|
|
10643 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionParametersKHR;
|
|
|
10644 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
10645
|
|
|
10646 public:
|
|
|
10647 VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10648
|
|
|
10649 VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs ) = default;
|
|
|
10650 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default;
|
|
|
10651
|
|
|
10652 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10653 VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) = default;
|
|
|
10654 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default;
|
|
|
10655 #else
|
|
|
10656 VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10657 : m_videoSessionParametersKHR( exchange( rhs.m_videoSessionParametersKHR, {} ) )
|
|
|
10658 {
|
|
|
10659 }
|
|
|
10660
|
|
|
10661 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10662 {
|
|
|
10663 m_videoSessionParametersKHR = exchange( rhs.m_videoSessionParametersKHR, {} );
|
|
|
10664 return *this;
|
|
|
10665 }
|
|
|
10666 #endif
|
|
|
10667
|
|
|
10668 VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10669
|
|
|
10670 VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
10671 : m_videoSessionParametersKHR( videoSessionParametersKHR )
|
|
|
10672 {
|
|
|
10673 }
|
|
|
10674
|
|
|
10675 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10676 VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
10677 {
|
|
|
10678 m_videoSessionParametersKHR = videoSessionParametersKHR;
|
|
|
10679 return *this;
|
|
|
10680 }
|
|
|
10681 #endif
|
|
|
10682
|
|
|
10683 VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10684 {
|
|
|
10685 m_videoSessionParametersKHR = {};
|
|
|
10686 return *this;
|
|
|
10687 }
|
|
|
10688
|
|
|
10689 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
10690 {
|
|
|
10691 return m_videoSessionParametersKHR;
|
|
|
10692 }
|
|
|
10693
|
|
|
10694 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10695 {
|
|
|
10696 return m_videoSessionParametersKHR != VK_NULL_HANDLE;
|
|
|
10697 }
|
|
|
10698
|
|
|
10699 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10700 {
|
|
|
10701 return m_videoSessionParametersKHR == VK_NULL_HANDLE;
|
|
|
10702 }
|
|
|
10703
|
|
|
10704 private:
|
|
|
10705 VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
|
|
|
10706 };
|
|
|
10707
|
|
|
10708 template <>
|
|
|
10709 struct CppType<ObjectType, ObjectType::eVideoSessionParametersKHR>
|
|
|
10710 {
|
|
|
10711 using Type = VideoSessionParametersKHR;
|
|
|
10712 };
|
|
|
10713
|
|
|
10714 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10715 template <>
|
|
|
10716 struct CppType<VkVideoSessionParametersKHR, VK_NULL_HANDLE>
|
|
|
10717 {
|
|
|
10718 using Type = VideoSessionParametersKHR;
|
|
|
10719 };
|
|
|
10720 #endif
|
|
|
10721
|
|
|
10722 template <>
|
|
|
10723 struct isVulkanHandleType<VideoSessionParametersKHR>
|
|
|
10724 {
|
|
|
10725 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10726 };
|
|
|
10727
|
|
|
10728 // wrapper class for handle VkPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKHR.html
|
|
|
10729 class PipelineBinaryKHR
|
|
|
10730 {
|
|
|
10731 public:
|
|
|
10732 using CType = VkPipelineBinaryKHR;
|
|
|
10733 using NativeType = VkPipelineBinaryKHR;
|
|
|
10734
|
|
|
10735 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineBinaryKHR;
|
|
|
10736 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown;
|
|
|
10737
|
|
|
10738 public:
|
|
|
10739 PipelineBinaryKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10740
|
|
|
10741 PipelineBinaryKHR( PipelineBinaryKHR const & rhs ) = default;
|
|
|
10742 PipelineBinaryKHR & operator=( PipelineBinaryKHR const & rhs ) = default;
|
|
|
10743
|
|
|
10744 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10745 PipelineBinaryKHR( PipelineBinaryKHR && rhs ) = default;
|
|
|
10746 PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) = default;
|
|
|
10747 #else
|
|
|
10748 PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( exchange( rhs.m_pipelineBinaryKHR, {} ) ) {}
|
|
|
10749
|
|
|
10750 PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10751 {
|
|
|
10752 m_pipelineBinaryKHR = exchange( rhs.m_pipelineBinaryKHR, {} );
|
|
|
10753 return *this;
|
|
|
10754 }
|
|
|
10755 #endif
|
|
|
10756
|
|
|
10757 VULKAN_HPP_CONSTEXPR PipelineBinaryKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10758
|
|
|
10759 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineBinaryKHR( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( pipelineBinaryKHR ) {}
|
|
|
10760
|
|
|
10761 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
10762 PipelineBinaryKHR & operator=( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
10763 {
|
|
|
10764 m_pipelineBinaryKHR = pipelineBinaryKHR;
|
|
|
10765 return *this;
|
|
|
10766 }
|
|
|
10767 #endif
|
|
|
10768
|
|
|
10769 PipelineBinaryKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10770 {
|
|
|
10771 m_pipelineBinaryKHR = {};
|
|
|
10772 return *this;
|
|
|
10773 }
|
|
|
10774
|
|
|
10775 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
10776 {
|
|
|
10777 return m_pipelineBinaryKHR;
|
|
|
10778 }
|
|
|
10779
|
|
|
10780 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
10781 {
|
|
|
10782 return m_pipelineBinaryKHR != VK_NULL_HANDLE;
|
|
|
10783 }
|
|
|
10784
|
|
|
10785 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
10786 {
|
|
|
10787 return m_pipelineBinaryKHR == VK_NULL_HANDLE;
|
|
|
10788 }
|
|
|
10789
|
|
|
10790 private:
|
|
|
10791 VkPipelineBinaryKHR m_pipelineBinaryKHR = {};
|
|
|
10792 };
|
|
|
10793
|
|
|
10794 template <>
|
|
|
10795 struct CppType<ObjectType, ObjectType::ePipelineBinaryKHR>
|
|
|
10796 {
|
|
|
10797 using Type = PipelineBinaryKHR;
|
|
|
10798 };
|
|
|
10799
|
|
|
10800 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
10801 template <>
|
|
|
10802 struct CppType<VkPipelineBinaryKHR, VK_NULL_HANDLE>
|
|
|
10803 {
|
|
|
10804 using Type = PipelineBinaryKHR;
|
|
|
10805 };
|
|
|
10806 #endif
|
|
|
10807
|
|
|
10808 template <>
|
|
|
10809 struct isVulkanHandleType<PipelineBinaryKHR>
|
|
|
10810 {
|
|
|
10811 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
10812 };
|
|
|
10813
|
|
|
10814 // wrapper class for handle VkQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueue.html
|
|
|
10815 class Queue
|
|
|
10816 {
|
|
|
10817 public:
|
|
|
10818 using CType = VkQueue;
|
|
|
10819 using NativeType = VkQueue;
|
|
|
10820
|
|
|
10821 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue;
|
|
|
10822 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueue;
|
|
|
10823
|
|
|
10824 public:
|
|
|
10825 Queue() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
10826
|
|
|
10827 Queue( Queue const & rhs ) = default;
|
|
|
10828 Queue & operator=( Queue const & rhs ) = default;
|
|
|
10829
|
|
|
10830 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
10831 Queue( Queue && rhs ) = default;
|
|
|
10832 Queue & operator=( Queue && rhs ) = default;
|
|
|
10833 #else
|
|
|
10834 Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT : m_queue( exchange( rhs.m_queue, {} ) ) {}
|
|
|
10835
|
|
|
10836 Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
10837 {
|
|
|
10838 m_queue = exchange( rhs.m_queue, {} );
|
|
|
10839 return *this;
|
|
|
10840 }
|
|
|
10841 #endif
|
|
|
10842
|
|
|
10843 VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
10844
|
|
|
10845 Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
|
|
|
10846
|
|
|
10847 Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
|
|
|
10848 {
|
|
|
10849 m_queue = queue;
|
|
|
10850 return *this;
|
|
|
10851 }
|
|
|
10852
|
|
|
10853 Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
10854 {
|
|
|
10855 m_queue = {};
|
|
|
10856 return *this;
|
|
|
10857 }
|
|
|
10858
|
|
|
10859 //=== VK_VERSION_1_0 ===
|
|
|
10860
|
|
|
10861 // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html
|
|
|
10862 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10863 VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount,
|
|
|
10864 const SubmitInfo * pSubmits,
|
|
|
10865 Fence fence,
|
|
|
10866 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10867 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10868 // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html
|
|
|
10869 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10870 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> const & submits,
|
|
|
10871 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
10872 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10873 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
10874
|
|
|
10875 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10876 // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html
|
|
|
10877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10878 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10879 #else
|
|
|
10880 // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html
|
|
|
10881 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10882 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10883 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
10884
|
|
|
10885 // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html
|
|
|
10886 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10887 VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount,
|
|
|
10888 const BindSparseInfo * pBindInfo,
|
|
|
10889 Fence fence,
|
|
|
10890 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10892 // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html
|
|
|
10893 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10894 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
10895 bindSparse( ArrayProxy<const BindSparseInfo> const & bindInfo,
|
|
|
10896 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
10897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
10899
|
|
|
10900 //=== VK_VERSION_1_3 ===
|
|
|
10901
|
|
|
10902 // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html
|
|
|
10903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10904 VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount,
|
|
|
10905 const SubmitInfo2 * pSubmits,
|
|
|
10906 Fence fence,
|
|
|
10907 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10909 // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html
|
|
|
10910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10911 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2( ArrayProxy<const SubmitInfo2> const & submits,
|
|
|
10912 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
10913 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
10915
|
|
|
10916 //=== VK_KHR_swapchain ===
|
|
|
10917
|
|
|
10918 // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html
|
|
|
10919 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10920 VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR * pPresentInfo,
|
|
|
10921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10923 // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html
|
|
|
10924 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10925 VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10926 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
10927
|
|
|
10928 //=== VK_EXT_debug_utils ===
|
|
|
10929
|
|
|
10930 // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see
|
|
|
10931 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html
|
|
|
10932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10933 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
|
|
|
10934 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10935 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10936 // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see
|
|
|
10937 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html
|
|
|
10938 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10939 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
10941
|
|
|
10942 // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see
|
|
|
10943 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html
|
|
|
10944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10945 void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10946
|
|
|
10947 // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see
|
|
|
10948 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html
|
|
|
10949 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10950 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo,
|
|
|
10951 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10953 // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see
|
|
|
10954 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html
|
|
|
10955 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10956 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
|
|
|
10957 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10958 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
10959
|
|
|
10960 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
10961
|
|
|
10962 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
|
|
|
10963 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10964 void getCheckpointDataNV( uint32_t * pCheckpointDataCount,
|
|
|
10965 CheckpointDataNV * pCheckpointData,
|
|
|
10966 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10967 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10968 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
|
|
|
10969 template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
|
|
|
10970 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
10971 typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, CheckpointDataNV>::value, int>::type = 0,
|
|
|
10972 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10973 VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
|
|
|
10974 getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10975 // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html
|
|
|
10976 template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
|
|
|
10977 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
10978 typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, CheckpointDataNV>::value, int>::type = 0,
|
|
|
10979 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10980 VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
|
|
|
10981 getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
10983
|
|
|
10984 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
|
|
|
10985 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10986 void getCheckpointData2NV( uint32_t * pCheckpointDataCount,
|
|
|
10987 CheckpointData2NV * pCheckpointData,
|
|
|
10988 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
10989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
10990 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
|
|
|
10991 template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
|
|
|
10992 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
10993 typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, CheckpointData2NV>::value, int>::type = 0,
|
|
|
10994 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
10995 VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
|
|
|
10996 getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
10997 // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html
|
|
|
10998 template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
|
|
|
10999 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11000 typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, CheckpointData2NV>::value, int>::type = 0,
|
|
|
11001 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11002 VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
|
|
|
11003 getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11005
|
|
|
11006 //=== VK_INTEL_performance_query ===
|
|
|
11007
|
|
|
11008 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11009 // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see
|
|
|
11010 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html
|
|
|
11011 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11012 VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration,
|
|
|
11013 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11014 #else
|
|
|
11015 // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see
|
|
|
11016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html
|
|
|
11017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11018 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11019 setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11020 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11021
|
|
|
11022 //=== VK_KHR_synchronization2 ===
|
|
|
11023
|
|
|
11024 // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html
|
|
|
11025 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11026 VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount,
|
|
|
11027 const SubmitInfo2 * pSubmits,
|
|
|
11028 Fence fence,
|
|
|
11029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11031 // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html
|
|
|
11032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11033 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11034 submit2KHR( ArrayProxy<const SubmitInfo2> const & submits,
|
|
|
11035 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11036 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11037 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11038
|
|
|
11039 //=== VK_NV_low_latency2 ===
|
|
|
11040
|
|
|
11041 // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html
|
|
|
11042 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11043 void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
|
|
|
11044 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11045 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11046 // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html
|
|
|
11047 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11048 void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo,
|
|
|
11049 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11050 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11051
|
|
|
11052 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
11053 //=== VK_OHOS_native_buffer ===
|
|
|
11054
|
|
|
11055 // wrapper function for command vkQueueSignalReleaseImageOHOS, see
|
|
|
11056 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
|
|
|
11057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11058 VULKAN_HPP_NODISCARD Result signalReleaseImageOHOS( uint32_t waitSemaphoreCount,
|
|
|
11059 const Semaphore * pWaitSemaphores,
|
|
|
11060 Image image,
|
|
|
11061 int32_t * pNativeFenceFd,
|
|
|
11062 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11063 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11064 // wrapper function for command vkQueueSignalReleaseImageOHOS, see
|
|
|
11065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
|
|
|
11066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11067 VULKAN_HPP_NODISCARD typename ResultValueType<int32_t>::type signalReleaseImageOHOS( ArrayProxy<const Semaphore> const & waitSemaphores,
|
|
|
11068 Image image,
|
|
|
11069 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11070 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11071 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
11072
|
|
|
11073 operator VkQueue() const VULKAN_HPP_NOEXCEPT
|
|
|
11074 {
|
|
|
11075 return m_queue;
|
|
|
11076 }
|
|
|
11077
|
|
|
11078 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
11079 {
|
|
|
11080 return m_queue != VK_NULL_HANDLE;
|
|
|
11081 }
|
|
|
11082
|
|
|
11083 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
11084 {
|
|
|
11085 return m_queue == VK_NULL_HANDLE;
|
|
|
11086 }
|
|
|
11087
|
|
|
11088 private:
|
|
|
11089 VkQueue m_queue = {};
|
|
|
11090 };
|
|
|
11091
|
|
|
11092 template <>
|
|
|
11093 struct CppType<ObjectType, ObjectType::eQueue>
|
|
|
11094 {
|
|
|
11095 using Type = Queue;
|
|
|
11096 };
|
|
|
11097
|
|
|
11098 template <>
|
|
|
11099 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eQueue>
|
|
|
11100 {
|
|
|
11101 using Type = Queue;
|
|
|
11102 };
|
|
|
11103
|
|
|
11104 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
11105 template <>
|
|
|
11106 struct CppType<VkQueue, VK_NULL_HANDLE>
|
|
|
11107 {
|
|
|
11108 using Type = Queue;
|
|
|
11109 };
|
|
|
11110 #endif
|
|
|
11111
|
|
|
11112 template <>
|
|
|
11113 struct isVulkanHandleType<Queue>
|
|
|
11114 {
|
|
|
11115 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
11116 };
|
|
|
11117
|
|
|
11118 // wrapper class for handle VkDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevice.html
|
|
|
11119 class Device
|
|
|
11120 {
|
|
|
11121 public:
|
|
|
11122 using CType = VkDevice;
|
|
|
11123 using NativeType = VkDevice;
|
|
|
11124
|
|
|
11125 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice;
|
|
|
11126 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDevice;
|
|
|
11127
|
|
|
11128 public:
|
|
|
11129 Device() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
11130
|
|
|
11131 Device( Device const & rhs ) = default;
|
|
|
11132 Device & operator=( Device const & rhs ) = default;
|
|
|
11133
|
|
|
11134 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
11135 Device( Device && rhs ) = default;
|
|
|
11136 Device & operator=( Device && rhs ) = default;
|
|
|
11137 #else
|
|
|
11138 Device( Device && rhs ) VULKAN_HPP_NOEXCEPT : m_device( exchange( rhs.m_device, {} ) ) {}
|
|
|
11139
|
|
|
11140 Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
11141 {
|
|
|
11142 m_device = exchange( rhs.m_device, {} );
|
|
|
11143 return *this;
|
|
|
11144 }
|
|
|
11145 #endif
|
|
|
11146
|
|
|
11147 VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
11148
|
|
|
11149 Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
|
|
|
11150
|
|
|
11151 Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
|
|
|
11152 {
|
|
|
11153 m_device = device;
|
|
|
11154 return *this;
|
|
|
11155 }
|
|
|
11156
|
|
|
11157 Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
11158 {
|
|
|
11159 m_device = {};
|
|
|
11160 return *this;
|
|
|
11161 }
|
|
|
11162
|
|
|
11163 //=== VK_VERSION_1_0 ===
|
|
|
11164
|
|
|
11165 // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html
|
|
|
11166 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11167 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11169 // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html
|
|
|
11170 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11171 PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11172 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11173
|
|
|
11174 // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html
|
|
|
11175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11176 void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11177 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11178 // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html
|
|
|
11179 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11180 void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11181 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11183
|
|
|
11184 // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html
|
|
|
11185 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11186 void getQueue( uint32_t queueFamilyIndex,
|
|
|
11187 uint32_t queueIndex,
|
|
|
11188 Queue * pQueue,
|
|
|
11189 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11190 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11191 // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html
|
|
|
11192 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11193 VULKAN_HPP_NODISCARD Queue getQueue( uint32_t queueFamilyIndex,
|
|
|
11194 uint32_t queueIndex,
|
|
|
11195 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11196 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11197
|
|
|
11198 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11199 // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html
|
|
|
11200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11201 VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11202 #else
|
|
|
11203 // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html
|
|
|
11204 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11205 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11206 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11207
|
|
|
11208 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
|
|
|
11209 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11210 VULKAN_HPP_NODISCARD Result allocateMemory( const MemoryAllocateInfo * pAllocateInfo,
|
|
|
11211 const AllocationCallbacks * pAllocator,
|
|
|
11212 DeviceMemory * pMemory,
|
|
|
11213 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11214 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11215 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
|
|
|
11216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11217 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceMemory>::type
|
|
|
11218 allocateMemory( const MemoryAllocateInfo & allocateInfo,
|
|
|
11219 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11220 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11221 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11222 // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html
|
|
|
11223 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11224 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DeviceMemory, Dispatch>>::type
|
|
|
11225 allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo,
|
|
|
11226 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11227 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11228 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11229 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11230
|
|
|
11231 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
|
|
|
11232 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11233 void freeMemory( DeviceMemory memory,
|
|
|
11234 const AllocationCallbacks * pAllocator,
|
|
|
11235 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11237 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
|
|
|
11238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11239 void freeMemory( DeviceMemory memory VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11240 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11241 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11242 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11243
|
|
|
11244 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
|
|
|
11245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11246 void( free )( DeviceMemory memory,
|
|
|
11247 const AllocationCallbacks * pAllocator,
|
|
|
11248 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11249 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11250 // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html
|
|
|
11251 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11252 void( free )( DeviceMemory memory,
|
|
|
11253 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11254 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11255 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11256
|
|
|
11257 // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html
|
|
|
11258 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11259 VULKAN_HPP_NODISCARD Result mapMemory( DeviceMemory memory,
|
|
|
11260 DeviceSize offset,
|
|
|
11261 DeviceSize size,
|
|
|
11262 MemoryMapFlags flags,
|
|
|
11263 void ** ppData,
|
|
|
11264 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11266 // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html
|
|
|
11267 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11268 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( DeviceMemory memory,
|
|
|
11269 DeviceSize offset,
|
|
|
11270 DeviceSize size,
|
|
|
11271 MemoryMapFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11272 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11274
|
|
|
11275 // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html
|
|
|
11276 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11277 void unmapMemory( DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11278
|
|
|
11279 // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html
|
|
|
11280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11281 VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount,
|
|
|
11282 const MappedMemoryRange * pMemoryRanges,
|
|
|
11283 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11284 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11285 // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html
|
|
|
11286 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11287 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11288 flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11289 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11290
|
|
|
11291 // wrapper function for command vkInvalidateMappedMemoryRanges, see
|
|
|
11292 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html
|
|
|
11293 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11294 VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount,
|
|
|
11295 const MappedMemoryRange * pMemoryRanges,
|
|
|
11296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11298 // wrapper function for command vkInvalidateMappedMemoryRanges, see
|
|
|
11299 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html
|
|
|
11300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11301 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11302 invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> const & memoryRanges,
|
|
|
11303 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11304 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11305
|
|
|
11306 // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html
|
|
|
11307 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11308 void getMemoryCommitment( DeviceMemory memory,
|
|
|
11309 DeviceSize * pCommittedMemoryInBytes,
|
|
|
11310 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11312 // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html
|
|
|
11313 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11314 VULKAN_HPP_NODISCARD DeviceSize getMemoryCommitment( DeviceMemory memory,
|
|
|
11315 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11317
|
|
|
11318 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11319 // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html
|
|
|
11320 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11321 VULKAN_HPP_NODISCARD Result bindBufferMemory( Buffer buffer,
|
|
|
11322 DeviceMemory memory,
|
|
|
11323 DeviceSize memoryOffset,
|
|
|
11324 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11325 #else
|
|
|
11326 // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html
|
|
|
11327 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11328 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11329 bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11330 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11331
|
|
|
11332 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11333 // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html
|
|
|
11334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11335 VULKAN_HPP_NODISCARD Result bindImageMemory( Image image,
|
|
|
11336 DeviceMemory memory,
|
|
|
11337 DeviceSize memoryOffset,
|
|
|
11338 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11339 #else
|
|
|
11340 // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html
|
|
|
11341 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11342 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11343 bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11344 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11345
|
|
|
11346 // wrapper function for command vkGetBufferMemoryRequirements, see
|
|
|
11347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html
|
|
|
11348 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11349 void getBufferMemoryRequirements( Buffer buffer,
|
|
|
11350 MemoryRequirements * pMemoryRequirements,
|
|
|
11351 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11353 // wrapper function for command vkGetBufferMemoryRequirements, see
|
|
|
11354 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html
|
|
|
11355 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11356 VULKAN_HPP_NODISCARD MemoryRequirements
|
|
|
11357 getBufferMemoryRequirements( Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11359
|
|
|
11360 // wrapper function for command vkGetImageMemoryRequirements, see
|
|
|
11361 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html
|
|
|
11362 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11363 void getImageMemoryRequirements( Image image,
|
|
|
11364 MemoryRequirements * pMemoryRequirements,
|
|
|
11365 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11367 // wrapper function for command vkGetImageMemoryRequirements, see
|
|
|
11368 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html
|
|
|
11369 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11370 VULKAN_HPP_NODISCARD MemoryRequirements getImageMemoryRequirements( Image image,
|
|
|
11371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11373
|
|
|
11374 // wrapper function for command vkGetImageSparseMemoryRequirements, see
|
|
|
11375 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
|
|
|
11376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11377 void getImageSparseMemoryRequirements( Image image,
|
|
|
11378 uint32_t * pSparseMemoryRequirementCount,
|
|
|
11379 SparseImageMemoryRequirements * pSparseMemoryRequirements,
|
|
|
11380 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11381 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11382 // wrapper function for command vkGetImageSparseMemoryRequirements, see
|
|
|
11383 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
|
|
|
11384 template <
|
|
|
11385 typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
|
|
|
11386 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11387 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, SparseImageMemoryRequirements>::value, int>::type = 0,
|
|
|
11388 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11389 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
|
|
|
11390 getImageSparseMemoryRequirements( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11391 // wrapper function for command vkGetImageSparseMemoryRequirements, see
|
|
|
11392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html
|
|
|
11393 template <
|
|
|
11394 typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
|
|
|
11395 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11396 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, SparseImageMemoryRequirements>::value, int>::type = 0,
|
|
|
11397 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11398 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
|
|
|
11399 getImageSparseMemoryRequirements( Image image,
|
|
|
11400 SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
|
|
|
11401 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11402 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11403
|
|
|
11404 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
|
|
|
11405 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11406 VULKAN_HPP_NODISCARD Result createFence( const FenceCreateInfo * pCreateInfo,
|
|
|
11407 const AllocationCallbacks * pAllocator,
|
|
|
11408 Fence * pFence,
|
|
|
11409 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11411 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
|
|
|
11412 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11413 VULKAN_HPP_NODISCARD typename ResultValueType<Fence>::type
|
|
|
11414 createFence( const FenceCreateInfo & createInfo,
|
|
|
11415 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11416 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11417 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11418 // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html
|
|
|
11419 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11420 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
|
|
|
11421 createFenceUnique( const FenceCreateInfo & createInfo,
|
|
|
11422 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11423 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11424 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11425 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11426
|
|
|
11427 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
|
|
|
11428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11429 void destroyFence( Fence fence,
|
|
|
11430 const AllocationCallbacks * pAllocator,
|
|
|
11431 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11432 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11433 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
|
|
|
11434 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11435 void destroyFence( Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11436 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11437 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11438 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11439
|
|
|
11440 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
|
|
|
11441 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11442 void destroy( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11443 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11444 // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html
|
|
|
11445 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11446 void destroy( Fence fence,
|
|
|
11447 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11448 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11449 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11450
|
|
|
11451 // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
|
|
|
11452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11453 VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount,
|
|
|
11454 const Fence * pFences,
|
|
|
11455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11456 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11457 // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
|
|
|
11458 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11459 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11460 resetFences( ArrayProxy<const Fence> const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11461 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11462
|
|
|
11463 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11464 // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html
|
|
|
11465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11466 VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11467 #else
|
|
|
11468 // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html
|
|
|
11469 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11470 VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11471 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11472
|
|
|
11473 // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html
|
|
|
11474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11475 VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount,
|
|
|
11476 const Fence * pFences,
|
|
|
11477 Bool32 waitAll,
|
|
|
11478 uint64_t timeout,
|
|
|
11479 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11481 // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html
|
|
|
11482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11483 VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const Fence> const & fences,
|
|
|
11484 Bool32 waitAll,
|
|
|
11485 uint64_t timeout,
|
|
|
11486 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11487 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11488
|
|
|
11489 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
|
|
|
11490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11491 VULKAN_HPP_NODISCARD Result createSemaphore( const SemaphoreCreateInfo * pCreateInfo,
|
|
|
11492 const AllocationCallbacks * pAllocator,
|
|
|
11493 Semaphore * pSemaphore,
|
|
|
11494 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11495 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11496 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
|
|
|
11497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11498 VULKAN_HPP_NODISCARD typename ResultValueType<Semaphore>::type
|
|
|
11499 createSemaphore( const SemaphoreCreateInfo & createInfo,
|
|
|
11500 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11501 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11502 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11503 // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html
|
|
|
11504 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11505 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Semaphore, Dispatch>>::type
|
|
|
11506 createSemaphoreUnique( const SemaphoreCreateInfo & createInfo,
|
|
|
11507 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11508 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11509 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11511
|
|
|
11512 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
|
|
|
11513 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11514 void destroySemaphore( Semaphore semaphore,
|
|
|
11515 const AllocationCallbacks * pAllocator,
|
|
|
11516 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11518 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
|
|
|
11519 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11520 void destroySemaphore( Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11521 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11522 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11523 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11524
|
|
|
11525 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
|
|
|
11526 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11527 void destroy( Semaphore semaphore,
|
|
|
11528 const AllocationCallbacks * pAllocator,
|
|
|
11529 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11531 // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html
|
|
|
11532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11533 void destroy( Semaphore semaphore,
|
|
|
11534 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11536 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11537
|
|
|
11538 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
|
|
|
11539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11540 VULKAN_HPP_NODISCARD Result createQueryPool( const QueryPoolCreateInfo * pCreateInfo,
|
|
|
11541 const AllocationCallbacks * pAllocator,
|
|
|
11542 QueryPool * pQueryPool,
|
|
|
11543 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11545 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
|
|
|
11546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11547 VULKAN_HPP_NODISCARD typename ResultValueType<QueryPool>::type
|
|
|
11548 createQueryPool( const QueryPoolCreateInfo & createInfo,
|
|
|
11549 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11550 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11551 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11552 // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
|
|
|
11553 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11554 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<QueryPool, Dispatch>>::type
|
|
|
11555 createQueryPoolUnique( const QueryPoolCreateInfo & createInfo,
|
|
|
11556 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11557 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11558 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11559 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11560
|
|
|
11561 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
|
|
|
11562 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11563 void destroyQueryPool( QueryPool queryPool,
|
|
|
11564 const AllocationCallbacks * pAllocator,
|
|
|
11565 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11567 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
|
|
|
11568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11569 void destroyQueryPool( QueryPool queryPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11570 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11571 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11572 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11573
|
|
|
11574 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
|
|
|
11575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11576 void destroy( QueryPool queryPool,
|
|
|
11577 const AllocationCallbacks * pAllocator,
|
|
|
11578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11579 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11580 // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html
|
|
|
11581 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11582 void destroy( QueryPool queryPool,
|
|
|
11583 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11584 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11585 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11586
|
|
|
11587 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
|
|
|
11588 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11589 VULKAN_HPP_NODISCARD Result getQueryPoolResults( QueryPool queryPool,
|
|
|
11590 uint32_t firstQuery,
|
|
|
11591 uint32_t queryCount,
|
|
|
11592 size_t dataSize,
|
|
|
11593 void * pData,
|
|
|
11594 DeviceSize stride,
|
|
|
11595 QueryResultFlags flags,
|
|
|
11596 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11597 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11598 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
|
|
|
11599 template <typename DataType,
|
|
|
11600 typename DataTypeAllocator = std::allocator<DataType>,
|
|
|
11601 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11602 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
|
|
|
11603 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11604 VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>>
|
|
|
11605 getQueryPoolResults( QueryPool queryPool,
|
|
|
11606 uint32_t firstQuery,
|
|
|
11607 uint32_t queryCount,
|
|
|
11608 size_t dataSize,
|
|
|
11609 DeviceSize stride,
|
|
|
11610 QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11611 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11612 // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html
|
|
|
11613 template <typename DataType,
|
|
|
11614 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11615 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11616 VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( QueryPool queryPool,
|
|
|
11617 uint32_t firstQuery,
|
|
|
11618 uint32_t queryCount,
|
|
|
11619 DeviceSize stride,
|
|
|
11620 QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11621 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11622 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11623
|
|
|
11624 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
|
|
|
11625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11626 VULKAN_HPP_NODISCARD Result createBuffer( const BufferCreateInfo * pCreateInfo,
|
|
|
11627 const AllocationCallbacks * pAllocator,
|
|
|
11628 Buffer * pBuffer,
|
|
|
11629 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11630 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11631 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
|
|
|
11632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11633 VULKAN_HPP_NODISCARD typename ResultValueType<Buffer>::type
|
|
|
11634 createBuffer( const BufferCreateInfo & createInfo,
|
|
|
11635 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11637 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11638 // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html
|
|
|
11639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11640 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Buffer, Dispatch>>::type
|
|
|
11641 createBufferUnique( const BufferCreateInfo & createInfo,
|
|
|
11642 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11643 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11644 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11645 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11646
|
|
|
11647 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
|
|
|
11648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11649 void destroyBuffer( Buffer buffer,
|
|
|
11650 const AllocationCallbacks * pAllocator,
|
|
|
11651 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11652 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11653 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
|
|
|
11654 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11655 void destroyBuffer( Buffer buffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11656 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11657 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11658 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11659
|
|
|
11660 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
|
|
|
11661 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11662 void
|
|
|
11663 destroy( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11664 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11665 // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html
|
|
|
11666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11667 void destroy( Buffer buffer,
|
|
|
11668 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11669 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11671
|
|
|
11672 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
|
|
|
11673 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11674 VULKAN_HPP_NODISCARD Result createImage( const ImageCreateInfo * pCreateInfo,
|
|
|
11675 const AllocationCallbacks * pAllocator,
|
|
|
11676 Image * pImage,
|
|
|
11677 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11678 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11679 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
|
|
|
11680 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11681 VULKAN_HPP_NODISCARD typename ResultValueType<Image>::type
|
|
|
11682 createImage( const ImageCreateInfo & createInfo,
|
|
|
11683 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11684 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11685 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11686 // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html
|
|
|
11687 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11688 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Image, Dispatch>>::type
|
|
|
11689 createImageUnique( const ImageCreateInfo & createInfo,
|
|
|
11690 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11691 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11692 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11693 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11694
|
|
|
11695 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
|
|
|
11696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11697 void destroyImage( Image image,
|
|
|
11698 const AllocationCallbacks * pAllocator,
|
|
|
11699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11700 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11701 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
|
|
|
11702 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11703 void destroyImage( Image image VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11704 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11705 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11706 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11707
|
|
|
11708 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
|
|
|
11709 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11710 void destroy( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11711 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11712 // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html
|
|
|
11713 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11714 void destroy( Image image,
|
|
|
11715 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11716 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11717 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11718
|
|
|
11719 // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html
|
|
|
11720 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11721 void getImageSubresourceLayout( Image image,
|
|
|
11722 const ImageSubresource * pSubresource,
|
|
|
11723 SubresourceLayout * pLayout,
|
|
|
11724 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11725 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11726 // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html
|
|
|
11727 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11728 VULKAN_HPP_NODISCARD SubresourceLayout getImageSubresourceLayout( Image image,
|
|
|
11729 const ImageSubresource & subresource,
|
|
|
11730 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11731 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11732
|
|
|
11733 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
|
|
|
11734 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11735 VULKAN_HPP_NODISCARD Result createImageView( const ImageViewCreateInfo * pCreateInfo,
|
|
|
11736 const AllocationCallbacks * pAllocator,
|
|
|
11737 ImageView * pView,
|
|
|
11738 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11740 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
|
|
|
11741 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11742 VULKAN_HPP_NODISCARD typename ResultValueType<ImageView>::type
|
|
|
11743 createImageView( const ImageViewCreateInfo & createInfo,
|
|
|
11744 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11745 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11746 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11747 // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html
|
|
|
11748 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11749 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ImageView, Dispatch>>::type
|
|
|
11750 createImageViewUnique( const ImageViewCreateInfo & createInfo,
|
|
|
11751 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11752 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11753 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11755
|
|
|
11756 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
|
|
|
11757 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11758 void destroyImageView( ImageView imageView,
|
|
|
11759 const AllocationCallbacks * pAllocator,
|
|
|
11760 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11761 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11762 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
|
|
|
11763 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11764 void destroyImageView( ImageView imageView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11765 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11766 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11767 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11768
|
|
|
11769 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
|
|
|
11770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11771 void destroy( ImageView imageView,
|
|
|
11772 const AllocationCallbacks * pAllocator,
|
|
|
11773 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11775 // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html
|
|
|
11776 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11777 void destroy( ImageView imageView,
|
|
|
11778 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11779 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11780 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11781
|
|
|
11782 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
|
|
|
11783 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11784 VULKAN_HPP_NODISCARD Result createCommandPool( const CommandPoolCreateInfo * pCreateInfo,
|
|
|
11785 const AllocationCallbacks * pAllocator,
|
|
|
11786 CommandPool * pCommandPool,
|
|
|
11787 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11788 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11789 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
|
|
|
11790 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11791 VULKAN_HPP_NODISCARD typename ResultValueType<CommandPool>::type
|
|
|
11792 createCommandPool( const CommandPoolCreateInfo & createInfo,
|
|
|
11793 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11794 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11795 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11796 // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html
|
|
|
11797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11798 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CommandPool, Dispatch>>::type
|
|
|
11799 createCommandPoolUnique( const CommandPoolCreateInfo & createInfo,
|
|
|
11800 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11801 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11802 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11803 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11804
|
|
|
11805 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
|
|
|
11806 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11807 void destroyCommandPool( CommandPool commandPool,
|
|
|
11808 const AllocationCallbacks * pAllocator,
|
|
|
11809 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11810 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11811 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
|
|
|
11812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11813 void destroyCommandPool( CommandPool commandPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11814 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11815 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11816 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11817
|
|
|
11818 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
|
|
|
11819 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11820 void destroy( CommandPool commandPool,
|
|
|
11821 const AllocationCallbacks * pAllocator,
|
|
|
11822 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11824 // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html
|
|
|
11825 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11826 void destroy( CommandPool commandPool,
|
|
|
11827 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11828 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11829 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11830
|
|
|
11831 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11832 // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
|
|
|
11833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11834 VULKAN_HPP_NODISCARD Result resetCommandPool( CommandPool commandPool,
|
|
|
11835 CommandPoolResetFlags flags,
|
|
|
11836 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11837 #else
|
|
|
11838 // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
|
|
|
11839 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11840 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11841 resetCommandPool( CommandPool commandPool,
|
|
|
11842 CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11843 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11844 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11845
|
|
|
11846 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
|
|
|
11847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11848 VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const CommandBufferAllocateInfo * pAllocateInfo,
|
|
|
11849 CommandBuffer * pCommandBuffers,
|
|
|
11850 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11851 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11852 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
|
|
|
11853 template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
|
|
|
11854 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11855 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, CommandBuffer>::value, int>::type = 0,
|
|
|
11856 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11857 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
|
|
|
11858 allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11859 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
|
|
|
11860 template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
|
|
|
11861 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11862 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, CommandBuffer>::value, int>::type = 0,
|
|
|
11863 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11864 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
|
|
|
11865 allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
|
|
|
11866 CommandBufferAllocator & commandBufferAllocator,
|
|
|
11867 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11868 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11869 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
|
|
|
11870 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11871 typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
|
|
|
11872 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type = 0,
|
|
|
11873 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11874 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
|
|
|
11875 allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11876 // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html
|
|
|
11877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
11878 typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
|
|
|
11879 typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type = 0,
|
|
|
11880 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11881 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
|
|
|
11882 allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
|
|
|
11883 CommandBufferAllocator & commandBufferAllocator,
|
|
|
11884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11885 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11886 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11887
|
|
|
11888 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
|
|
|
11889 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11890 void freeCommandBuffers( CommandPool commandPool,
|
|
|
11891 uint32_t commandBufferCount,
|
|
|
11892 const CommandBuffer * pCommandBuffers,
|
|
|
11893 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11895 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
|
|
|
11896 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11897 void freeCommandBuffers( CommandPool commandPool,
|
|
|
11898 ArrayProxy<const CommandBuffer> const & commandBuffers,
|
|
|
11899 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11901
|
|
|
11902 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
|
|
|
11903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11904 void( free )( CommandPool commandPool,
|
|
|
11905 uint32_t commandBufferCount,
|
|
|
11906 const CommandBuffer * pCommandBuffers,
|
|
|
11907 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11909 // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html
|
|
|
11910 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11911 void( free )( CommandPool commandPool,
|
|
|
11912 ArrayProxy<const CommandBuffer> const & commandBuffers,
|
|
|
11913 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11915
|
|
|
11916 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
|
|
|
11917 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11918 VULKAN_HPP_NODISCARD Result createEvent( const EventCreateInfo * pCreateInfo,
|
|
|
11919 const AllocationCallbacks * pAllocator,
|
|
|
11920 Event * pEvent,
|
|
|
11921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11923 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
|
|
|
11924 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11925 VULKAN_HPP_NODISCARD typename ResultValueType<Event>::type
|
|
|
11926 createEvent( const EventCreateInfo & createInfo,
|
|
|
11927 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11928 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11929 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
11930 // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html
|
|
|
11931 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11932 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Event, Dispatch>>::type
|
|
|
11933 createEventUnique( const EventCreateInfo & createInfo,
|
|
|
11934 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11935 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11936 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
11937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11938
|
|
|
11939 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
|
|
|
11940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11941 void destroyEvent( Event event,
|
|
|
11942 const AllocationCallbacks * pAllocator,
|
|
|
11943 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11944 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11945 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
|
|
|
11946 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11947 void destroyEvent( Event event VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
11948 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11949 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11951
|
|
|
11952 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
|
|
|
11953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11954 void destroy( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11955 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11956 // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html
|
|
|
11957 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11958 void destroy( Event event,
|
|
|
11959 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
11960 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11961 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
11962
|
|
|
11963 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11964 // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html
|
|
|
11965 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11966 VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11967 #else
|
|
|
11968 // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html
|
|
|
11969 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11970 VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11971 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11972
|
|
|
11973 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11974 // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html
|
|
|
11975 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11976 VULKAN_HPP_NODISCARD Result setEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11977 #else
|
|
|
11978 // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html
|
|
|
11979 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11980 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( Event event,
|
|
|
11981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11982 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11983
|
|
|
11984 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
11985 // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
|
|
|
11986 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11987 VULKAN_HPP_NODISCARD Result resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
11988 #else
|
|
|
11989 // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
|
|
|
11990 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11991 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
11992 resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
11993 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
11994
|
|
|
11995 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
|
|
|
11996 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
11997 VULKAN_HPP_NODISCARD Result createBufferView( const BufferViewCreateInfo * pCreateInfo,
|
|
|
11998 const AllocationCallbacks * pAllocator,
|
|
|
11999 BufferView * pView,
|
|
|
12000 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12002 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
|
|
|
12003 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12004 VULKAN_HPP_NODISCARD typename ResultValueType<BufferView>::type
|
|
|
12005 createBufferView( const BufferViewCreateInfo & createInfo,
|
|
|
12006 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12007 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12008 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12009 // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html
|
|
|
12010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12011 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<BufferView, Dispatch>>::type
|
|
|
12012 createBufferViewUnique( const BufferViewCreateInfo & createInfo,
|
|
|
12013 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12014 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12015 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12016 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12017
|
|
|
12018 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
|
|
|
12019 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12020 void destroyBufferView( BufferView bufferView,
|
|
|
12021 const AllocationCallbacks * pAllocator,
|
|
|
12022 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12023 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12024 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
|
|
|
12025 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12026 void destroyBufferView( BufferView bufferView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12027 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12028 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12029 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12030
|
|
|
12031 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
|
|
|
12032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12033 void destroy( BufferView bufferView,
|
|
|
12034 const AllocationCallbacks * pAllocator,
|
|
|
12035 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12037 // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html
|
|
|
12038 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12039 void destroy( BufferView bufferView,
|
|
|
12040 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12041 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12043
|
|
|
12044 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
|
|
|
12045 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12046 VULKAN_HPP_NODISCARD Result createShaderModule( const ShaderModuleCreateInfo * pCreateInfo,
|
|
|
12047 const AllocationCallbacks * pAllocator,
|
|
|
12048 ShaderModule * pShaderModule,
|
|
|
12049 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12050 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12051 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
|
|
|
12052 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12053 VULKAN_HPP_NODISCARD typename ResultValueType<ShaderModule>::type
|
|
|
12054 createShaderModule( const ShaderModuleCreateInfo & createInfo,
|
|
|
12055 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12057 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12058 // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html
|
|
|
12059 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12060 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ShaderModule, Dispatch>>::type
|
|
|
12061 createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo,
|
|
|
12062 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12063 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12064 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12065 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12066
|
|
|
12067 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
|
|
|
12068 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12069 void destroyShaderModule( ShaderModule shaderModule,
|
|
|
12070 const AllocationCallbacks * pAllocator,
|
|
|
12071 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12072 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12073 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
|
|
|
12074 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12075 void destroyShaderModule( ShaderModule shaderModule VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12076 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12077 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12078 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12079
|
|
|
12080 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
|
|
|
12081 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12082 void destroy( ShaderModule shaderModule,
|
|
|
12083 const AllocationCallbacks * pAllocator,
|
|
|
12084 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12085 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12086 // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html
|
|
|
12087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12088 void destroy( ShaderModule shaderModule,
|
|
|
12089 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12091 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12092
|
|
|
12093 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
|
|
|
12094 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12095 VULKAN_HPP_NODISCARD Result createPipelineCache( const PipelineCacheCreateInfo * pCreateInfo,
|
|
|
12096 const AllocationCallbacks * pAllocator,
|
|
|
12097 PipelineCache * pPipelineCache,
|
|
|
12098 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12099 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12100 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
|
|
|
12101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12102 VULKAN_HPP_NODISCARD typename ResultValueType<PipelineCache>::type
|
|
|
12103 createPipelineCache( const PipelineCacheCreateInfo & createInfo,
|
|
|
12104 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12105 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12106 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12107 // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html
|
|
|
12108 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12109 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PipelineCache, Dispatch>>::type
|
|
|
12110 createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo,
|
|
|
12111 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12112 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12113 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12114 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12115
|
|
|
12116 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
|
|
|
12117 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12118 void destroyPipelineCache( PipelineCache pipelineCache,
|
|
|
12119 const AllocationCallbacks * pAllocator,
|
|
|
12120 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12121 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12122 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
|
|
|
12123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12124 void destroyPipelineCache( PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12125 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12126 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12127 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12128
|
|
|
12129 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
|
|
|
12130 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12131 void destroy( PipelineCache pipelineCache,
|
|
|
12132 const AllocationCallbacks * pAllocator,
|
|
|
12133 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12134 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12135 // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html
|
|
|
12136 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12137 void destroy( PipelineCache pipelineCache,
|
|
|
12138 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12139 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12140 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12141
|
|
|
12142 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
|
|
|
12143 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12144 VULKAN_HPP_NODISCARD Result getPipelineCacheData( PipelineCache pipelineCache,
|
|
|
12145 size_t * pDataSize,
|
|
|
12146 void * pData,
|
|
|
12147 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12149 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
|
|
|
12150 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
12151 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12152 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
12153 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12154 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
|
|
|
12155 getPipelineCacheData( PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12156 // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html
|
|
|
12157 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
12158 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12159 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
12160 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12161 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData(
|
|
|
12162 PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12164
|
|
|
12165 // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html
|
|
|
12166 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12167 VULKAN_HPP_NODISCARD Result mergePipelineCaches( PipelineCache dstCache,
|
|
|
12168 uint32_t srcCacheCount,
|
|
|
12169 const PipelineCache * pSrcCaches,
|
|
|
12170 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12171 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12172 // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html
|
|
|
12173 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12174 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergePipelineCaches(
|
|
|
12175 PipelineCache dstCache, ArrayProxy<const PipelineCache> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12176 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12177
|
|
|
12178 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
|
|
|
12179 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12180 VULKAN_HPP_NODISCARD Result createComputePipelines( PipelineCache pipelineCache,
|
|
|
12181 uint32_t createInfoCount,
|
|
|
12182 const ComputePipelineCreateInfo * pCreateInfos,
|
|
|
12183 const AllocationCallbacks * pAllocator,
|
|
|
12184 Pipeline * pPipelines,
|
|
|
12185 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12186 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12187 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
|
|
|
12188 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
12189 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12190 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
12191 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12192 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
12193 createComputePipelines( PipelineCache pipelineCache,
|
|
|
12194 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
|
|
|
12195 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12196 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12197 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
|
|
|
12198 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
12199 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12200 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
12201 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12202 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
12203 createComputePipelines( PipelineCache pipelineCache,
|
|
|
12204 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
|
|
|
12205 Optional<const AllocationCallbacks> allocator,
|
|
|
12206 PipelineAllocator & pipelineAllocator,
|
|
|
12207 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12208 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
|
|
|
12209 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12210 VULKAN_HPP_NODISCARD ResultValue<Pipeline> createComputePipeline( PipelineCache pipelineCache,
|
|
|
12211 const ComputePipelineCreateInfo & createInfo,
|
|
|
12212 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12213 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12214 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12215 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
|
|
|
12216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12217 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
12218 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
12219 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12220 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
12221 createComputePipelinesUnique( PipelineCache pipelineCache,
|
|
|
12222 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
|
|
|
12223 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12224 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12225 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
|
|
|
12226 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12227 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
12228 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
12229 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12230 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
12231 createComputePipelinesUnique( PipelineCache pipelineCache,
|
|
|
12232 ArrayProxy<const ComputePipelineCreateInfo> const & createInfos,
|
|
|
12233 Optional<const AllocationCallbacks> allocator,
|
|
|
12234 PipelineAllocator & pipelineAllocator,
|
|
|
12235 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12236 // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html
|
|
|
12237 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12238 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
|
|
|
12239 createComputePipelineUnique( PipelineCache pipelineCache,
|
|
|
12240 const ComputePipelineCreateInfo & createInfo,
|
|
|
12241 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12242 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12243 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12245
|
|
|
12246 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
|
|
|
12247 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12248 void destroyPipeline( Pipeline pipeline,
|
|
|
12249 const AllocationCallbacks * pAllocator,
|
|
|
12250 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12252 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
|
|
|
12253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12254 void destroyPipeline( Pipeline pipeline VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12255 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12258
|
|
|
12259 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
|
|
|
12260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12261 void destroy( Pipeline pipeline,
|
|
|
12262 const AllocationCallbacks * pAllocator,
|
|
|
12263 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12264 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12265 // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html
|
|
|
12266 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12267 void destroy( Pipeline pipeline,
|
|
|
12268 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12269 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12271
|
|
|
12272 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
|
|
|
12273 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12274 VULKAN_HPP_NODISCARD Result createPipelineLayout( const PipelineLayoutCreateInfo * pCreateInfo,
|
|
|
12275 const AllocationCallbacks * pAllocator,
|
|
|
12276 PipelineLayout * pPipelineLayout,
|
|
|
12277 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12278 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12279 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
|
|
|
12280 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12281 VULKAN_HPP_NODISCARD typename ResultValueType<PipelineLayout>::type
|
|
|
12282 createPipelineLayout( const PipelineLayoutCreateInfo & createInfo,
|
|
|
12283 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12284 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12285 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12286 // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html
|
|
|
12287 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12288 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PipelineLayout, Dispatch>>::type
|
|
|
12289 createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo,
|
|
|
12290 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12291 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12292 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12293 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12294
|
|
|
12295 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
|
|
|
12296 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12297 void destroyPipelineLayout( PipelineLayout pipelineLayout,
|
|
|
12298 const AllocationCallbacks * pAllocator,
|
|
|
12299 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12300 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12301 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
|
|
|
12302 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12303 void destroyPipelineLayout( PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12304 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12305 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12307
|
|
|
12308 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
|
|
|
12309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12310 void destroy( PipelineLayout pipelineLayout,
|
|
|
12311 const AllocationCallbacks * pAllocator,
|
|
|
12312 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12314 // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html
|
|
|
12315 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12316 void destroy( PipelineLayout pipelineLayout,
|
|
|
12317 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12318 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12319 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12320
|
|
|
12321 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
|
|
|
12322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12323 VULKAN_HPP_NODISCARD Result createSampler( const SamplerCreateInfo * pCreateInfo,
|
|
|
12324 const AllocationCallbacks * pAllocator,
|
|
|
12325 Sampler * pSampler,
|
|
|
12326 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12328 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
|
|
|
12329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12330 VULKAN_HPP_NODISCARD typename ResultValueType<Sampler>::type
|
|
|
12331 createSampler( const SamplerCreateInfo & createInfo,
|
|
|
12332 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12333 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12334 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12335 // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html
|
|
|
12336 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12337 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Sampler, Dispatch>>::type
|
|
|
12338 createSamplerUnique( const SamplerCreateInfo & createInfo,
|
|
|
12339 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12340 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12341 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12343
|
|
|
12344 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
|
|
|
12345 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12346 void destroySampler( Sampler sampler,
|
|
|
12347 const AllocationCallbacks * pAllocator,
|
|
|
12348 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12349 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12350 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
|
|
|
12351 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12352 void destroySampler( Sampler sampler VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12353 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12354 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12355 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12356
|
|
|
12357 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
|
|
|
12358 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12359 void
|
|
|
12360 destroy( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12361 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12362 // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html
|
|
|
12363 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12364 void destroy( Sampler sampler,
|
|
|
12365 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12366 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12367 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12368
|
|
|
12369 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
|
|
|
12370 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12371 VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo * pCreateInfo,
|
|
|
12372 const AllocationCallbacks * pAllocator,
|
|
|
12373 DescriptorSetLayout * pSetLayout,
|
|
|
12374 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12376 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
|
|
|
12377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12378 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorSetLayout>::type
|
|
|
12379 createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
|
|
|
12380 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12382 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12383 // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html
|
|
|
12384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12385 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorSetLayout, Dispatch>>::type
|
|
|
12386 createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
|
|
|
12387 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12388 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12389 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12390 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12391
|
|
|
12392 // wrapper function for command vkDestroyDescriptorSetLayout, see
|
|
|
12393 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
|
|
|
12394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12395 void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout,
|
|
|
12396 const AllocationCallbacks * pAllocator,
|
|
|
12397 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12398 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12399 // wrapper function for command vkDestroyDescriptorSetLayout, see
|
|
|
12400 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
|
|
|
12401 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12402 void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12403 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12404 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12405 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12406
|
|
|
12407 // wrapper function for command vkDestroyDescriptorSetLayout, see
|
|
|
12408 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
|
|
|
12409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12410 void destroy( DescriptorSetLayout descriptorSetLayout,
|
|
|
12411 const AllocationCallbacks * pAllocator,
|
|
|
12412 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12414 // wrapper function for command vkDestroyDescriptorSetLayout, see
|
|
|
12415 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html
|
|
|
12416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12417 void destroy( DescriptorSetLayout descriptorSetLayout,
|
|
|
12418 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12419 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12420 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12421
|
|
|
12422 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
|
|
|
12423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12424 VULKAN_HPP_NODISCARD Result createDescriptorPool( const DescriptorPoolCreateInfo * pCreateInfo,
|
|
|
12425 const AllocationCallbacks * pAllocator,
|
|
|
12426 DescriptorPool * pDescriptorPool,
|
|
|
12427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12428 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12429 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
|
|
|
12430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12431 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorPool>::type
|
|
|
12432 createDescriptorPool( const DescriptorPoolCreateInfo & createInfo,
|
|
|
12433 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12434 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12435 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12436 // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html
|
|
|
12437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12438 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorPool, Dispatch>>::type
|
|
|
12439 createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo,
|
|
|
12440 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12441 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12442 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12443 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12444
|
|
|
12445 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
|
|
|
12446 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12447 void destroyDescriptorPool( DescriptorPool descriptorPool,
|
|
|
12448 const AllocationCallbacks * pAllocator,
|
|
|
12449 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12451 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
|
|
|
12452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12453 void destroyDescriptorPool( DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12454 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12456 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12457
|
|
|
12458 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
|
|
|
12459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12460 void destroy( DescriptorPool descriptorPool,
|
|
|
12461 const AllocationCallbacks * pAllocator,
|
|
|
12462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12464 // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html
|
|
|
12465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12466 void destroy( DescriptorPool descriptorPool,
|
|
|
12467 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12468 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12469 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12470
|
|
|
12471 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12472 // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
|
|
|
12473 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12474 VULKAN_HPP_NODISCARD Result resetDescriptorPool( DescriptorPool descriptorPool,
|
|
|
12475 DescriptorPoolResetFlags flags,
|
|
|
12476 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12477 #else
|
|
|
12478 // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
|
|
|
12479 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12480 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
12481 resetDescriptorPool( DescriptorPool descriptorPool,
|
|
|
12482 DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12483 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12484 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
12485
|
|
|
12486 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
|
|
|
12487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12488 VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const DescriptorSetAllocateInfo * pAllocateInfo,
|
|
|
12489 DescriptorSet * pDescriptorSets,
|
|
|
12490 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12492 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
|
|
|
12493 template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
|
|
|
12494 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12495 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, DescriptorSet>::value, int>::type = 0,
|
|
|
12496 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12497 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
|
|
|
12498 allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12499 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
|
|
|
12500 template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
|
|
|
12501 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12502 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, DescriptorSet>::value, int>::type = 0,
|
|
|
12503 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12504 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
|
|
|
12505 allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
|
|
|
12506 DescriptorSetAllocator & descriptorSetAllocator,
|
|
|
12507 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12508 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12509 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
|
|
|
12510 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12511 typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
|
|
|
12512 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type = 0,
|
|
|
12513 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12514 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
|
|
|
12515 allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12516 // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
|
|
|
12517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12518 typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
|
|
|
12519 typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type = 0,
|
|
|
12520 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12521 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
|
|
|
12522 allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
|
|
|
12523 DescriptorSetAllocator & descriptorSetAllocator,
|
|
|
12524 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12525 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12526 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12527
|
|
|
12528 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
|
|
|
12529 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12530 VULKAN_HPP_NODISCARD Result freeDescriptorSets( DescriptorPool descriptorPool,
|
|
|
12531 uint32_t descriptorSetCount,
|
|
|
12532 const DescriptorSet * pDescriptorSets,
|
|
|
12533 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12534 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12535 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
|
|
|
12536 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12537 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
12538 freeDescriptorSets( DescriptorPool descriptorPool,
|
|
|
12539 ArrayProxy<const DescriptorSet> const & descriptorSets,
|
|
|
12540 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12541 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12542
|
|
|
12543 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
|
|
|
12544 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12545 VULKAN_HPP_NODISCARD Result( free )( DescriptorPool descriptorPool,
|
|
|
12546 uint32_t descriptorSetCount,
|
|
|
12547 const DescriptorSet * pDescriptorSets,
|
|
|
12548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12550 // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
|
|
|
12551 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12552 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type( free )( DescriptorPool descriptorPool,
|
|
|
12553 ArrayProxy<const DescriptorSet> const & descriptorSets,
|
|
|
12554 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12555 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12556
|
|
|
12557 // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html
|
|
|
12558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12559 void updateDescriptorSets( uint32_t descriptorWriteCount,
|
|
|
12560 const WriteDescriptorSet * pDescriptorWrites,
|
|
|
12561 uint32_t descriptorCopyCount,
|
|
|
12562 const CopyDescriptorSet * pDescriptorCopies,
|
|
|
12563 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12565 // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html
|
|
|
12566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12567 void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> const & descriptorWrites,
|
|
|
12568 ArrayProxy<const CopyDescriptorSet> const & descriptorCopies,
|
|
|
12569 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12571
|
|
|
12572 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
|
|
|
12573 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12574 VULKAN_HPP_NODISCARD Result createGraphicsPipelines( PipelineCache pipelineCache,
|
|
|
12575 uint32_t createInfoCount,
|
|
|
12576 const GraphicsPipelineCreateInfo * pCreateInfos,
|
|
|
12577 const AllocationCallbacks * pAllocator,
|
|
|
12578 Pipeline * pPipelines,
|
|
|
12579 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12580 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12581 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
|
|
|
12582 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
12583 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12584 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
12585 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12586 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
12587 createGraphicsPipelines( PipelineCache pipelineCache,
|
|
|
12588 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
|
|
|
12589 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12590 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12591 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
|
|
|
12592 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
12593 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12594 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
12595 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12596 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
12597 createGraphicsPipelines( PipelineCache pipelineCache,
|
|
|
12598 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
|
|
|
12599 Optional<const AllocationCallbacks> allocator,
|
|
|
12600 PipelineAllocator & pipelineAllocator,
|
|
|
12601 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12602 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
|
|
|
12603 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12604 VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline( PipelineCache pipelineCache,
|
|
|
12605 const GraphicsPipelineCreateInfo & createInfo,
|
|
|
12606 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12607 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12608 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12609 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
|
|
|
12610 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12611 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
12612 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
12613 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12614 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
12615 createGraphicsPipelinesUnique( PipelineCache pipelineCache,
|
|
|
12616 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
|
|
|
12617 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12618 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12619 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
|
|
|
12620 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12621 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
12622 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
12623 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12624 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
12625 createGraphicsPipelinesUnique( PipelineCache pipelineCache,
|
|
|
12626 ArrayProxy<const GraphicsPipelineCreateInfo> const & createInfos,
|
|
|
12627 Optional<const AllocationCallbacks> allocator,
|
|
|
12628 PipelineAllocator & pipelineAllocator,
|
|
|
12629 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12630 // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html
|
|
|
12631 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12632 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
|
|
|
12633 createGraphicsPipelineUnique( PipelineCache pipelineCache,
|
|
|
12634 const GraphicsPipelineCreateInfo & createInfo,
|
|
|
12635 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12637 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12638 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12639
|
|
|
12640 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
|
|
|
12641 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12642 VULKAN_HPP_NODISCARD Result createFramebuffer( const FramebufferCreateInfo * pCreateInfo,
|
|
|
12643 const AllocationCallbacks * pAllocator,
|
|
|
12644 Framebuffer * pFramebuffer,
|
|
|
12645 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12647 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
|
|
|
12648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12649 VULKAN_HPP_NODISCARD typename ResultValueType<Framebuffer>::type
|
|
|
12650 createFramebuffer( const FramebufferCreateInfo & createInfo,
|
|
|
12651 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12652 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12653 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12654 // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html
|
|
|
12655 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12656 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Framebuffer, Dispatch>>::type
|
|
|
12657 createFramebufferUnique( const FramebufferCreateInfo & createInfo,
|
|
|
12658 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12660 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12661 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12662
|
|
|
12663 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
|
|
|
12664 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12665 void destroyFramebuffer( Framebuffer framebuffer,
|
|
|
12666 const AllocationCallbacks * pAllocator,
|
|
|
12667 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12669 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
|
|
|
12670 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12671 void destroyFramebuffer( Framebuffer framebuffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12672 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12673 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12674 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12675
|
|
|
12676 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
|
|
|
12677 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12678 void destroy( Framebuffer framebuffer,
|
|
|
12679 const AllocationCallbacks * pAllocator,
|
|
|
12680 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12681 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12682 // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html
|
|
|
12683 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12684 void destroy( Framebuffer framebuffer,
|
|
|
12685 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12686 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12688
|
|
|
12689 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
|
|
|
12690 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12691 VULKAN_HPP_NODISCARD Result createRenderPass( const RenderPassCreateInfo * pCreateInfo,
|
|
|
12692 const AllocationCallbacks * pAllocator,
|
|
|
12693 RenderPass * pRenderPass,
|
|
|
12694 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12696 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
|
|
|
12697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12698 VULKAN_HPP_NODISCARD typename ResultValueType<RenderPass>::type
|
|
|
12699 createRenderPass( const RenderPassCreateInfo & createInfo,
|
|
|
12700 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12701 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12702 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12703 // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html
|
|
|
12704 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12705 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
|
|
|
12706 createRenderPassUnique( const RenderPassCreateInfo & createInfo,
|
|
|
12707 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12708 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12709 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12711
|
|
|
12712 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
|
|
|
12713 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12714 void destroyRenderPass( RenderPass renderPass,
|
|
|
12715 const AllocationCallbacks * pAllocator,
|
|
|
12716 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12718 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
|
|
|
12719 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12720 void destroyRenderPass( RenderPass renderPass VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12721 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12722 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12723 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12724
|
|
|
12725 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
|
|
|
12726 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12727 void destroy( RenderPass renderPass,
|
|
|
12728 const AllocationCallbacks * pAllocator,
|
|
|
12729 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12730 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12731 // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html
|
|
|
12732 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12733 void destroy( RenderPass renderPass,
|
|
|
12734 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12735 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12736 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12737
|
|
|
12738 // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html
|
|
|
12739 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12740 void getRenderAreaGranularity( RenderPass renderPass,
|
|
|
12741 Extent2D * pGranularity,
|
|
|
12742 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12744 // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html
|
|
|
12745 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12746 VULKAN_HPP_NODISCARD Extent2D getRenderAreaGranularity( RenderPass renderPass,
|
|
|
12747 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12748 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12749
|
|
|
12750 //=== VK_VERSION_1_1 ===
|
|
|
12751
|
|
|
12752 // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html
|
|
|
12753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12754 VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount,
|
|
|
12755 const BindBufferMemoryInfo * pBindInfos,
|
|
|
12756 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12757 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12758 // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html
|
|
|
12759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12760 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
12761 bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12763
|
|
|
12764 // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html
|
|
|
12765 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12766 VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount,
|
|
|
12767 const BindImageMemoryInfo * pBindInfos,
|
|
|
12768 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12769 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12770 // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html
|
|
|
12771 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12772 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
12773 bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12774 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12775
|
|
|
12776 // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see
|
|
|
12777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html
|
|
|
12778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12779 void getGroupPeerMemoryFeatures( uint32_t heapIndex,
|
|
|
12780 uint32_t localDeviceIndex,
|
|
|
12781 uint32_t remoteDeviceIndex,
|
|
|
12782 PeerMemoryFeatureFlags * pPeerMemoryFeatures,
|
|
|
12783 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12784 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12785 // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see
|
|
|
12786 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html
|
|
|
12787 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12788 VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags
|
|
|
12789 getGroupPeerMemoryFeatures( uint32_t heapIndex,
|
|
|
12790 uint32_t localDeviceIndex,
|
|
|
12791 uint32_t remoteDeviceIndex,
|
|
|
12792 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12793 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12794
|
|
|
12795 // wrapper function for command vkGetImageMemoryRequirements2, see
|
|
|
12796 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
|
|
|
12797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12798 void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 * pInfo,
|
|
|
12799 MemoryRequirements2 * pMemoryRequirements,
|
|
|
12800 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12802 // wrapper function for command vkGetImageMemoryRequirements2, see
|
|
|
12803 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
|
|
|
12804 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12805 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2(
|
|
|
12806 const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12807 // wrapper function for command vkGetImageMemoryRequirements2, see
|
|
|
12808 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html
|
|
|
12809 template <typename X,
|
|
|
12810 typename Y,
|
|
|
12811 typename... Z,
|
|
|
12812 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12813 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12814 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
12815 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info,
|
|
|
12816 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12817 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12818
|
|
|
12819 // wrapper function for command vkGetBufferMemoryRequirements2, see
|
|
|
12820 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
|
|
|
12821 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12822 void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 * pInfo,
|
|
|
12823 MemoryRequirements2 * pMemoryRequirements,
|
|
|
12824 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12825 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12826 // wrapper function for command vkGetBufferMemoryRequirements2, see
|
|
|
12827 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
|
|
|
12828 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12829 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2(
|
|
|
12830 const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12831 // wrapper function for command vkGetBufferMemoryRequirements2, see
|
|
|
12832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html
|
|
|
12833 template <typename X,
|
|
|
12834 typename Y,
|
|
|
12835 typename... Z,
|
|
|
12836 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12837 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12838 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
12839 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info,
|
|
|
12840 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12842
|
|
|
12843 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
|
|
|
12844 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
|
|
|
12845 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12846 void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 * pInfo,
|
|
|
12847 uint32_t * pSparseMemoryRequirementCount,
|
|
|
12848 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
|
|
|
12849 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12850 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12851 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
|
|
|
12852 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
|
|
|
12853 template <
|
|
|
12854 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
12855 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12856 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
12857 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12858 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
12859 getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12860 // wrapper function for command vkGetImageSparseMemoryRequirements2, see
|
|
|
12861 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html
|
|
|
12862 template <
|
|
|
12863 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
12864 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12865 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
12866 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12867 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
12868 getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
|
|
|
12869 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
|
|
|
12870 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12871 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12872
|
|
|
12873 // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html
|
|
|
12874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12875 void trimCommandPool( CommandPool commandPool,
|
|
|
12876 CommandPoolTrimFlags flags,
|
|
|
12877 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12878
|
|
|
12879 // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html
|
|
|
12880 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12881 void
|
|
|
12882 getQueue2( const DeviceQueueInfo2 * pQueueInfo, Queue * pQueue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12883 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12884 // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html
|
|
|
12885 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12886 VULKAN_HPP_NODISCARD Queue getQueue2( const DeviceQueueInfo2 & queueInfo,
|
|
|
12887 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12889
|
|
|
12890 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
|
|
|
12891 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
|
|
|
12892 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12893 VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo * pCreateInfo,
|
|
|
12894 const AllocationCallbacks * pAllocator,
|
|
|
12895 DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
|
|
|
12896 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12898 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
|
|
|
12899 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
|
|
|
12900 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12901 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorUpdateTemplate>::type
|
|
|
12902 createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo,
|
|
|
12903 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12904 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12905 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
12906 // wrapper function for command vkCreateDescriptorUpdateTemplate, see
|
|
|
12907 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html
|
|
|
12908 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12909 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
|
|
|
12910 createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
|
|
|
12911 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12912 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
12913 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
12914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12915
|
|
|
12916 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
|
|
|
12917 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
|
|
|
12918 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12919 void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
12920 const AllocationCallbacks * pAllocator,
|
|
|
12921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12923 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
|
|
|
12924 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
|
|
|
12925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12926 void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
12927 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12928 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12929 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12930
|
|
|
12931 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
|
|
|
12932 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
|
|
|
12933 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12934 void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
12935 const AllocationCallbacks * pAllocator,
|
|
|
12936 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12937 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12938 // wrapper function for command vkDestroyDescriptorUpdateTemplate, see
|
|
|
12939 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html
|
|
|
12940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12941 void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
12942 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
12943 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12944 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12945
|
|
|
12946 // wrapper function for command vkUpdateDescriptorSetWithTemplate, see
|
|
|
12947 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html
|
|
|
12948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12949 void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet,
|
|
|
12950 DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
12951 const void * pData,
|
|
|
12952 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12953 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12954 // wrapper function for command vkUpdateDescriptorSetWithTemplate, see
|
|
|
12955 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html
|
|
|
12956 template <typename DataType,
|
|
|
12957 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12958 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12959 void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet,
|
|
|
12960 DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
12961 DataType const & data,
|
|
|
12962 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12964
|
|
|
12965 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
|
|
|
12966 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
|
|
|
12967 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12968 void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo * pCreateInfo,
|
|
|
12969 DescriptorSetLayoutSupport * pSupport,
|
|
|
12970 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12971 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12972 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
|
|
|
12973 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
|
|
|
12974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12975 VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
|
|
|
12976 const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12977 // wrapper function for command vkGetDescriptorSetLayoutSupport, see
|
|
|
12978 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html
|
|
|
12979 template <typename X,
|
|
|
12980 typename Y,
|
|
|
12981 typename... Z,
|
|
|
12982 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
12983 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12984 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
12985 getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo,
|
|
|
12986 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12987 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
12988
|
|
|
12989 // wrapper function for command vkCreateSamplerYcbcrConversion, see
|
|
|
12990 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
|
|
|
12991 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
12992 VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo * pCreateInfo,
|
|
|
12993 const AllocationCallbacks * pAllocator,
|
|
|
12994 SamplerYcbcrConversion * pYcbcrConversion,
|
|
|
12995 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
12996 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
12997 // wrapper function for command vkCreateSamplerYcbcrConversion, see
|
|
|
12998 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
|
|
|
12999 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13000 VULKAN_HPP_NODISCARD typename ResultValueType<SamplerYcbcrConversion>::type
|
|
|
13001 createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
|
|
|
13002 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13003 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13004 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13005 // wrapper function for command vkCreateSamplerYcbcrConversion, see
|
|
|
13006 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html
|
|
|
13007 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13008 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
|
|
|
13009 createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
|
|
|
13010 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13011 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13012 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13013 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13014
|
|
|
13015 // wrapper function for command vkDestroySamplerYcbcrConversion, see
|
|
|
13016 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
|
|
|
13017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13018 void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion,
|
|
|
13019 const AllocationCallbacks * pAllocator,
|
|
|
13020 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13022 // wrapper function for command vkDestroySamplerYcbcrConversion, see
|
|
|
13023 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
|
|
|
13024 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13025 void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
13026 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13027 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13029
|
|
|
13030 // wrapper function for command vkDestroySamplerYcbcrConversion, see
|
|
|
13031 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
|
|
|
13032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13033 void destroy( SamplerYcbcrConversion ycbcrConversion,
|
|
|
13034 const AllocationCallbacks * pAllocator,
|
|
|
13035 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13037 // wrapper function for command vkDestroySamplerYcbcrConversion, see
|
|
|
13038 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html
|
|
|
13039 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13040 void destroy( SamplerYcbcrConversion ycbcrConversion,
|
|
|
13041 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13044
|
|
|
13045 //=== VK_VERSION_1_2 ===
|
|
|
13046
|
|
|
13047 // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html
|
|
|
13048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13049 void resetQueryPool( QueryPool queryPool,
|
|
|
13050 uint32_t firstQuery,
|
|
|
13051 uint32_t queryCount,
|
|
|
13052 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13053
|
|
|
13054 // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html
|
|
|
13055 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13056 VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( Semaphore semaphore,
|
|
|
13057 uint64_t * pValue,
|
|
|
13058 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13060 // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html
|
|
|
13061 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13062 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( Semaphore semaphore,
|
|
|
13063 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13064 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13065
|
|
|
13066 // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html
|
|
|
13067 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13068 VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo * pWaitInfo,
|
|
|
13069 uint64_t timeout,
|
|
|
13070 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13072 // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html
|
|
|
13073 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13074 VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
|
|
|
13075 uint64_t timeout,
|
|
|
13076 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13077 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13078
|
|
|
13079 // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html
|
|
|
13080 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13081 VULKAN_HPP_NODISCARD Result signalSemaphore( const SemaphoreSignalInfo * pSignalInfo,
|
|
|
13082 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13084 // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html
|
|
|
13085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13086 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13087 signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13088 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13089
|
|
|
13090 // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html
|
|
|
13091 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13092 DeviceAddress getBufferAddress( const BufferDeviceAddressInfo * pInfo,
|
|
|
13093 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13095 // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html
|
|
|
13096 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13097 DeviceAddress getBufferAddress( const BufferDeviceAddressInfo & info,
|
|
|
13098 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13099 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13100
|
|
|
13101 // wrapper function for command vkGetBufferOpaqueCaptureAddress, see
|
|
|
13102 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html
|
|
|
13103 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13104 uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo * pInfo,
|
|
|
13105 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13107 // wrapper function for command vkGetBufferOpaqueCaptureAddress, see
|
|
|
13108 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html
|
|
|
13109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13110 uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
|
|
|
13111 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13112 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13113
|
|
|
13114 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see
|
|
|
13115 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html
|
|
|
13116 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13117 uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
|
|
|
13118 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13119 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13120 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see
|
|
|
13121 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html
|
|
|
13122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13123 uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
|
|
|
13124 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13126
|
|
|
13127 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
|
|
|
13128 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13129 VULKAN_HPP_NODISCARD Result createRenderPass2( const RenderPassCreateInfo2 * pCreateInfo,
|
|
|
13130 const AllocationCallbacks * pAllocator,
|
|
|
13131 RenderPass * pRenderPass,
|
|
|
13132 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13133 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13134 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
|
|
|
13135 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13136 VULKAN_HPP_NODISCARD typename ResultValueType<RenderPass>::type
|
|
|
13137 createRenderPass2( const RenderPassCreateInfo2 & createInfo,
|
|
|
13138 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13139 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13140 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13141 // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html
|
|
|
13142 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13143 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
|
|
|
13144 createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo,
|
|
|
13145 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13146 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13147 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13148 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13149
|
|
|
13150 //=== VK_VERSION_1_3 ===
|
|
|
13151
|
|
|
13152 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
|
|
|
13153 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13154 VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const PrivateDataSlotCreateInfo * pCreateInfo,
|
|
|
13155 const AllocationCallbacks * pAllocator,
|
|
|
13156 PrivateDataSlot * pPrivateDataSlot,
|
|
|
13157 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13158 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13159 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
|
|
|
13160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13161 VULKAN_HPP_NODISCARD typename ResultValueType<PrivateDataSlot>::type
|
|
|
13162 createPrivateDataSlot( const PrivateDataSlotCreateInfo & createInfo,
|
|
|
13163 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13164 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13165 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13166 // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html
|
|
|
13167 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13168 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PrivateDataSlot, Dispatch>>::type
|
|
|
13169 createPrivateDataSlotUnique( const PrivateDataSlotCreateInfo & createInfo,
|
|
|
13170 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13171 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13172 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13174
|
|
|
13175 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
|
|
|
13176 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13177 void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot,
|
|
|
13178 const AllocationCallbacks * pAllocator,
|
|
|
13179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13180 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13181 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
|
|
|
13182 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13183 void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
13184 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13185 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13186 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13187
|
|
|
13188 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
|
|
|
13189 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13190 void destroy( PrivateDataSlot privateDataSlot,
|
|
|
13191 const AllocationCallbacks * pAllocator,
|
|
|
13192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13194 // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html
|
|
|
13195 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13196 void destroy( PrivateDataSlot privateDataSlot,
|
|
|
13197 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13198 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13200
|
|
|
13201 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13202 // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
|
|
|
13203 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13204 VULKAN_HPP_NODISCARD Result setPrivateData( ObjectType objectType,
|
|
|
13205 uint64_t objectHandle,
|
|
|
13206 PrivateDataSlot privateDataSlot,
|
|
|
13207 uint64_t data,
|
|
|
13208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13209 #else
|
|
|
13210 // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
|
|
|
13211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13212 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13213 setPrivateData( ObjectType objectType,
|
|
|
13214 uint64_t objectHandle,
|
|
|
13215 PrivateDataSlot privateDataSlot,
|
|
|
13216 uint64_t data,
|
|
|
13217 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13218 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
13219
|
|
|
13220 // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html
|
|
|
13221 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13222 void getPrivateData( ObjectType objectType,
|
|
|
13223 uint64_t objectHandle,
|
|
|
13224 PrivateDataSlot privateDataSlot,
|
|
|
13225 uint64_t * pData,
|
|
|
13226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13227 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13228 // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html
|
|
|
13229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13230 VULKAN_HPP_NODISCARD uint64_t getPrivateData( ObjectType objectType,
|
|
|
13231 uint64_t objectHandle,
|
|
|
13232 PrivateDataSlot privateDataSlot,
|
|
|
13233 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13234 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13235
|
|
|
13236 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
|
|
|
13237 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
|
|
|
13238 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13239 void getBufferMemoryRequirements( const DeviceBufferMemoryRequirements * pInfo,
|
|
|
13240 MemoryRequirements2 * pMemoryRequirements,
|
|
|
13241 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13242 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13243 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
|
|
|
13244 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
|
|
|
13245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13246 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements(
|
|
|
13247 const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13248 // wrapper function for command vkGetDeviceBufferMemoryRequirements, see
|
|
|
13249 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html
|
|
|
13250 template <typename X,
|
|
|
13251 typename Y,
|
|
|
13252 typename... Z,
|
|
|
13253 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13254 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13255 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
13256 getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info,
|
|
|
13257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13258 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13259
|
|
|
13260 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
|
|
|
13261 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
|
|
|
13262 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13263 void getImageMemoryRequirements( const DeviceImageMemoryRequirements * pInfo,
|
|
|
13264 MemoryRequirements2 * pMemoryRequirements,
|
|
|
13265 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13266 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13267 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
|
|
|
13268 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
|
|
|
13269 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13270 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements(
|
|
|
13271 const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13272 // wrapper function for command vkGetDeviceImageMemoryRequirements, see
|
|
|
13273 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html
|
|
|
13274 template <typename X,
|
|
|
13275 typename Y,
|
|
|
13276 typename... Z,
|
|
|
13277 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13278 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13279 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
13280 getImageMemoryRequirements( const DeviceImageMemoryRequirements & info,
|
|
|
13281 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13282 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13283
|
|
|
13284 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
|
|
|
13285 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
|
|
|
13286 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13287 void getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements * pInfo,
|
|
|
13288 uint32_t * pSparseMemoryRequirementCount,
|
|
|
13289 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
|
|
|
13290 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13292 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
|
|
|
13293 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
|
|
|
13294 template <
|
|
|
13295 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
13296 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13297 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
13298 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13299 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
13300 getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13301 // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see
|
|
|
13302 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html
|
|
|
13303 template <
|
|
|
13304 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
13305 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13306 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
13307 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13308 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
13309 getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info,
|
|
|
13310 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
|
|
|
13311 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13313
|
|
|
13314 //=== VK_VERSION_1_4 ===
|
|
|
13315
|
|
|
13316 // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html
|
|
|
13317 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13318 VULKAN_HPP_NODISCARD Result mapMemory2( const MemoryMapInfo * pMemoryMapInfo,
|
|
|
13319 void ** ppData,
|
|
|
13320 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13322 // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html
|
|
|
13323 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13324 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2( const MemoryMapInfo & memoryMapInfo,
|
|
|
13325 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13326 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13327
|
|
|
13328 // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
|
|
|
13329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13330 VULKAN_HPP_NODISCARD Result unmapMemory2( const MemoryUnmapInfo * pMemoryUnmapInfo,
|
|
|
13331 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13333 // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
|
|
|
13334 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13335 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13336 unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13337 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13338
|
|
|
13339 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
|
|
|
13340 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
|
|
|
13341 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13342 void getImageSubresourceLayout( const DeviceImageSubresourceInfo * pInfo,
|
|
|
13343 SubresourceLayout2 * pLayout,
|
|
|
13344 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13346 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
|
|
|
13347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
|
|
|
13348 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13349 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info,
|
|
|
13350 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13351 // wrapper function for command vkGetDeviceImageSubresourceLayout, see
|
|
|
13352 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html
|
|
|
13353 template <typename X,
|
|
|
13354 typename Y,
|
|
|
13355 typename... Z,
|
|
|
13356 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13357 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13358 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
13359 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info,
|
|
|
13360 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13361 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13362
|
|
|
13363 // wrapper function for command vkGetImageSubresourceLayout2, see
|
|
|
13364 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
|
|
|
13365 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13366 void getImageSubresourceLayout2( Image image,
|
|
|
13367 const ImageSubresource2 * pSubresource,
|
|
|
13368 SubresourceLayout2 * pLayout,
|
|
|
13369 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13370 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13371 // wrapper function for command vkGetImageSubresourceLayout2, see
|
|
|
13372 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
|
|
|
13373 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13374 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2( Image image,
|
|
|
13375 const ImageSubresource2 & subresource,
|
|
|
13376 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13377 // wrapper function for command vkGetImageSubresourceLayout2, see
|
|
|
13378 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html
|
|
|
13379 template <typename X,
|
|
|
13380 typename Y,
|
|
|
13381 typename... Z,
|
|
|
13382 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13383 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13384 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageSubresourceLayout2(
|
|
|
13385 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13386 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13387
|
|
|
13388 // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html
|
|
|
13389 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13390 VULKAN_HPP_NODISCARD Result copyMemoryToImage( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
|
|
|
13391 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13392 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13393 // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html
|
|
|
13394 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13395 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13396 copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13398
|
|
|
13399 // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html
|
|
|
13400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13401 VULKAN_HPP_NODISCARD Result copyImageToMemory( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
|
|
|
13402 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13404 // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html
|
|
|
13405 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13406 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13407 copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13409
|
|
|
13410 // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html
|
|
|
13411 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13412 VULKAN_HPP_NODISCARD Result copyImageToImage( const CopyImageToImageInfo * pCopyImageToImageInfo,
|
|
|
13413 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13415 // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html
|
|
|
13416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13417 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13418 copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13420
|
|
|
13421 // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html
|
|
|
13422 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13423 VULKAN_HPP_NODISCARD Result transitionImageLayout( uint32_t transitionCount,
|
|
|
13424 const HostImageLayoutTransitionInfo * pTransitions,
|
|
|
13425 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13427 // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html
|
|
|
13428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13429 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13430 transitionImageLayout( ArrayProxy<const HostImageLayoutTransitionInfo> const & transitions,
|
|
|
13431 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13432 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13433
|
|
|
13434 // wrapper function for command vkGetRenderingAreaGranularity, see
|
|
|
13435 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html
|
|
|
13436 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13437 void getRenderingAreaGranularity( const RenderingAreaInfo * pRenderingAreaInfo,
|
|
|
13438 Extent2D * pGranularity,
|
|
|
13439 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13441 // wrapper function for command vkGetRenderingAreaGranularity, see
|
|
|
13442 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html
|
|
|
13443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13444 VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo,
|
|
|
13445 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13446 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13447
|
|
|
13448 //=== VK_KHR_swapchain ===
|
|
|
13449
|
|
|
13450 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
|
|
|
13451 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13452 VULKAN_HPP_NODISCARD Result createSwapchainKHR( const SwapchainCreateInfoKHR * pCreateInfo,
|
|
|
13453 const AllocationCallbacks * pAllocator,
|
|
|
13454 SwapchainKHR * pSwapchain,
|
|
|
13455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13456 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13457 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
|
|
|
13458 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13459 VULKAN_HPP_NODISCARD typename ResultValueType<SwapchainKHR>::type
|
|
|
13460 createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo,
|
|
|
13461 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13463 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13464 // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html
|
|
|
13465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13466 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
|
|
|
13467 createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
|
|
|
13468 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13470 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13472
|
|
|
13473 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
|
|
|
13474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13475 void destroySwapchainKHR( SwapchainKHR swapchain,
|
|
|
13476 const AllocationCallbacks * pAllocator,
|
|
|
13477 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13479 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
|
|
|
13480 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13481 void destroySwapchainKHR( SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
13482 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13483 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13485
|
|
|
13486 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
|
|
|
13487 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13488 void destroy( SwapchainKHR swapchain,
|
|
|
13489 const AllocationCallbacks * pAllocator,
|
|
|
13490 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13492 // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html
|
|
|
13493 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13494 void destroy( SwapchainKHR swapchain,
|
|
|
13495 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13496 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13498
|
|
|
13499 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
|
|
|
13500 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13501 VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( SwapchainKHR swapchain,
|
|
|
13502 uint32_t * pSwapchainImageCount,
|
|
|
13503 Image * pSwapchainImages,
|
|
|
13504 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13506 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
|
|
|
13507 template <typename ImageAllocator = std::allocator<Image>,
|
|
|
13508 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13509 typename std::enable_if<std::is_same<typename ImageAllocator::value_type, Image>::value, int>::type = 0,
|
|
|
13510 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13511 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
|
|
|
13512 getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13513 // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html
|
|
|
13514 template <typename ImageAllocator = std::allocator<Image>,
|
|
|
13515 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13516 typename std::enable_if<std::is_same<typename ImageAllocator::value_type, Image>::value, int>::type = 0,
|
|
|
13517 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13518 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
|
|
|
13519 getSwapchainImagesKHR( SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13520 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13521
|
|
|
13522 // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html
|
|
|
13523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13524 VULKAN_HPP_NODISCARD Result acquireNextImageKHR( SwapchainKHR swapchain,
|
|
|
13525 uint64_t timeout,
|
|
|
13526 Semaphore semaphore,
|
|
|
13527 Fence fence,
|
|
|
13528 uint32_t * pImageIndex,
|
|
|
13529 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13531 // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html
|
|
|
13532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13533 VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain,
|
|
|
13534 uint64_t timeout,
|
|
|
13535 Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
13536 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
13537 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13538 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13539
|
|
|
13540 // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see
|
|
|
13541 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html
|
|
|
13542 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13543 VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
|
|
|
13544 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13545 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13546 // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see
|
|
|
13547 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html
|
|
|
13548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13549 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type
|
|
|
13550 getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13551 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13552
|
|
|
13553 // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see
|
|
|
13554 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html
|
|
|
13555 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13556 VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( SurfaceKHR surface,
|
|
|
13557 DeviceGroupPresentModeFlagsKHR * pModes,
|
|
|
13558 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13560 // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see
|
|
|
13561 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html
|
|
|
13562 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13563 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceGroupPresentModeFlagsKHR>::type
|
|
|
13564 getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13565 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13566
|
|
|
13567 // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html
|
|
|
13568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13569 VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const AcquireNextImageInfoKHR * pAcquireInfo,
|
|
|
13570 uint32_t * pImageIndex,
|
|
|
13571 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13572 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13573 // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html
|
|
|
13574 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13575 VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo,
|
|
|
13576 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13577 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13578
|
|
|
13579 //=== VK_KHR_display_swapchain ===
|
|
|
13580
|
|
|
13581 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
|
|
|
13582 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13583 VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount,
|
|
|
13584 const SwapchainCreateInfoKHR * pCreateInfos,
|
|
|
13585 const AllocationCallbacks * pAllocator,
|
|
|
13586 SwapchainKHR * pSwapchains,
|
|
|
13587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13589 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
|
|
|
13590 template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
|
|
|
13591 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13592 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, SwapchainKHR>::value, int>::type = 0,
|
|
|
13593 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13594 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
|
|
|
13595 createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
|
|
|
13596 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13597 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13598 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
|
|
|
13599 template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
|
|
|
13600 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13601 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, SwapchainKHR>::value, int>::type = 0,
|
|
|
13602 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13603 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
|
|
|
13604 createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
|
|
|
13605 Optional<const AllocationCallbacks> allocator,
|
|
|
13606 SwapchainKHRAllocator & swapchainKHRAllocator,
|
|
|
13607 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13608 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
|
|
|
13609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13610 VULKAN_HPP_NODISCARD typename ResultValueType<SwapchainKHR>::type
|
|
|
13611 createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo,
|
|
|
13612 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13613 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13614 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13615 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
|
|
|
13616 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13617 typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
|
|
|
13618 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type = 0,
|
|
|
13619 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13620 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
|
|
|
13621 createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
|
|
|
13622 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13623 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13624 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
|
|
|
13625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13626 typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
|
|
|
13627 typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type = 0,
|
|
|
13628 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13629 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
|
|
|
13630 createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> const & createInfos,
|
|
|
13631 Optional<const AllocationCallbacks> allocator,
|
|
|
13632 SwapchainKHRAllocator & swapchainKHRAllocator,
|
|
|
13633 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13634 // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html
|
|
|
13635 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13636 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
|
|
|
13637 createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
|
|
|
13638 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13639 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13640 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13641 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13642
|
|
|
13643 //=== VK_EXT_debug_marker ===
|
|
|
13644
|
|
|
13645 // wrapper function for command vkDebugMarkerSetObjectTagEXT, see
|
|
|
13646 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html
|
|
|
13647 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13648 VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT * pTagInfo,
|
|
|
13649 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13651 // wrapper function for command vkDebugMarkerSetObjectTagEXT, see
|
|
|
13652 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html
|
|
|
13653 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13654 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13655 debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13656 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13657
|
|
|
13658 // wrapper function for command vkDebugMarkerSetObjectNameEXT, see
|
|
|
13659 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html
|
|
|
13660 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13661 VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT * pNameInfo,
|
|
|
13662 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13663 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13664 // wrapper function for command vkDebugMarkerSetObjectNameEXT, see
|
|
|
13665 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html
|
|
|
13666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13667 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13668 debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13669 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13670
|
|
|
13671 //=== VK_KHR_video_queue ===
|
|
|
13672
|
|
|
13673 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
|
|
|
13674 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13675 VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VideoSessionCreateInfoKHR * pCreateInfo,
|
|
|
13676 const AllocationCallbacks * pAllocator,
|
|
|
13677 VideoSessionKHR * pVideoSession,
|
|
|
13678 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13680 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
|
|
|
13681 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13682 VULKAN_HPP_NODISCARD typename ResultValueType<VideoSessionKHR>::type
|
|
|
13683 createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo,
|
|
|
13684 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13685 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13686 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13687 // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html
|
|
|
13688 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13689 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VideoSessionKHR, Dispatch>>::type
|
|
|
13690 createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo,
|
|
|
13691 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13692 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13693 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13694 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13695
|
|
|
13696 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
|
|
|
13697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13698 void destroyVideoSessionKHR( VideoSessionKHR videoSession,
|
|
|
13699 const AllocationCallbacks * pAllocator,
|
|
|
13700 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13702 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
|
|
|
13703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13704 void destroyVideoSessionKHR( VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
13705 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13706 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13707 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13708
|
|
|
13709 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
|
|
|
13710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13711 void destroy( VideoSessionKHR videoSession,
|
|
|
13712 const AllocationCallbacks * pAllocator,
|
|
|
13713 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13715 // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html
|
|
|
13716 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13717 void destroy( VideoSessionKHR videoSession,
|
|
|
13718 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13719 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13720 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13721
|
|
|
13722 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
|
|
|
13723 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
|
|
|
13724 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13725 VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession,
|
|
|
13726 uint32_t * pMemoryRequirementsCount,
|
|
|
13727 VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
|
|
|
13728 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13729 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13730 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
|
|
|
13731 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
|
|
|
13732 template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VideoSessionMemoryRequirementsKHR>,
|
|
|
13733 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13734 typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VideoSessionMemoryRequirementsKHR>::value,
|
|
|
13735 int>::type = 0,
|
|
|
13736 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13737 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
|
|
|
13738 getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13739 // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
|
|
|
13740 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html
|
|
|
13741 template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VideoSessionMemoryRequirementsKHR>,
|
|
|
13742 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13743 typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VideoSessionMemoryRequirementsKHR>::value,
|
|
|
13744 int>::type = 0,
|
|
|
13745 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13746 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
|
|
|
13747 getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession,
|
|
|
13748 VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
|
|
|
13749 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13750 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13751
|
|
|
13752 // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html
|
|
|
13753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13754 VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VideoSessionKHR videoSession,
|
|
|
13755 uint32_t bindSessionMemoryInfoCount,
|
|
|
13756 const BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
|
|
|
13757 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13759 // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html
|
|
|
13760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13761 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13762 bindVideoSessionMemoryKHR( VideoSessionKHR videoSession,
|
|
|
13763 ArrayProxy<const BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,
|
|
|
13764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13765 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13766
|
|
|
13767 // wrapper function for command vkCreateVideoSessionParametersKHR, see
|
|
|
13768 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
|
|
|
13769 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13770 VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR * pCreateInfo,
|
|
|
13771 const AllocationCallbacks * pAllocator,
|
|
|
13772 VideoSessionParametersKHR * pVideoSessionParameters,
|
|
|
13773 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13775 // wrapper function for command vkCreateVideoSessionParametersKHR, see
|
|
|
13776 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
|
|
|
13777 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13778 VULKAN_HPP_NODISCARD typename ResultValueType<VideoSessionParametersKHR>::type
|
|
|
13779 createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
|
|
|
13780 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13781 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13782 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13783 // wrapper function for command vkCreateVideoSessionParametersKHR, see
|
|
|
13784 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html
|
|
|
13785 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13786 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VideoSessionParametersKHR, Dispatch>>::type
|
|
|
13787 createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
|
|
|
13788 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13789 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13790 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13792
|
|
|
13793 // wrapper function for command vkUpdateVideoSessionParametersKHR, see
|
|
|
13794 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html
|
|
|
13795 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13796 VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
|
|
|
13797 const VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
|
|
|
13798 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13800 // wrapper function for command vkUpdateVideoSessionParametersKHR, see
|
|
|
13801 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html
|
|
|
13802 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13803 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
13804 updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
|
|
|
13805 const VideoSessionParametersUpdateInfoKHR & updateInfo,
|
|
|
13806 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13808
|
|
|
13809 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
|
|
|
13810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
|
|
|
13811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13812 void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters,
|
|
|
13813 const AllocationCallbacks * pAllocator,
|
|
|
13814 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13815 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13816 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
|
|
|
13817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
|
|
|
13818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13819 void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
13820 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13821 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13822 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13823
|
|
|
13824 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
|
|
|
13825 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
|
|
|
13826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13827 void destroy( VideoSessionParametersKHR videoSessionParameters,
|
|
|
13828 const AllocationCallbacks * pAllocator,
|
|
|
13829 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13831 // wrapper function for command vkDestroyVideoSessionParametersKHR, see
|
|
|
13832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html
|
|
|
13833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13834 void destroy( VideoSessionParametersKHR videoSessionParameters,
|
|
|
13835 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13836 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13838
|
|
|
13839 //=== VK_NVX_binary_import ===
|
|
|
13840
|
|
|
13841 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
|
|
|
13842 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13843 VULKAN_HPP_NODISCARD Result createCuModuleNVX( const CuModuleCreateInfoNVX * pCreateInfo,
|
|
|
13844 const AllocationCallbacks * pAllocator,
|
|
|
13845 CuModuleNVX * pModule,
|
|
|
13846 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13848 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
|
|
|
13849 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13850 VULKAN_HPP_NODISCARD typename ResultValueType<CuModuleNVX>::type
|
|
|
13851 createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo,
|
|
|
13852 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13853 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13854 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13855 // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html
|
|
|
13856 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13857 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CuModuleNVX, Dispatch>>::type
|
|
|
13858 createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo,
|
|
|
13859 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13860 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13861 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13862 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13863
|
|
|
13864 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
|
|
|
13865 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13866 VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const CuFunctionCreateInfoNVX * pCreateInfo,
|
|
|
13867 const AllocationCallbacks * pAllocator,
|
|
|
13868 CuFunctionNVX * pFunction,
|
|
|
13869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13871 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
|
|
|
13872 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13873 VULKAN_HPP_NODISCARD typename ResultValueType<CuFunctionNVX>::type
|
|
|
13874 createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo,
|
|
|
13875 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13876 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13877 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
13878 // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html
|
|
|
13879 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13880 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CuFunctionNVX, Dispatch>>::type
|
|
|
13881 createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo,
|
|
|
13882 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13883 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13884 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
13885 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13886
|
|
|
13887 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
|
|
|
13888 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13889 void destroyCuModuleNVX( CuModuleNVX module,
|
|
|
13890 const AllocationCallbacks * pAllocator,
|
|
|
13891 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13892 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13893 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
|
|
|
13894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13895 void destroyCuModuleNVX( CuModuleNVX module,
|
|
|
13896 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13899
|
|
|
13900 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
|
|
|
13901 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13902 void destroy( CuModuleNVX module,
|
|
|
13903 const AllocationCallbacks * pAllocator,
|
|
|
13904 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13906 // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html
|
|
|
13907 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13908 void destroy( CuModuleNVX module,
|
|
|
13909 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13910 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13911 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13912
|
|
|
13913 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
|
|
|
13914 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13915 void destroyCuFunctionNVX( CuFunctionNVX function,
|
|
|
13916 const AllocationCallbacks * pAllocator,
|
|
|
13917 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13918 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13919 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
|
|
|
13920 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13921 void destroyCuFunctionNVX( CuFunctionNVX function,
|
|
|
13922 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13923 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13925
|
|
|
13926 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
|
|
|
13927 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13928 void destroy( CuFunctionNVX function,
|
|
|
13929 const AllocationCallbacks * pAllocator,
|
|
|
13930 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13931 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13932 // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html
|
|
|
13933 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13934 void destroy( CuFunctionNVX function,
|
|
|
13935 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
13936 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13938
|
|
|
13939 //=== VK_NVX_image_view_handle ===
|
|
|
13940
|
|
|
13941 // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html
|
|
|
13942 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13943 uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX * pInfo,
|
|
|
13944 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13946 // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html
|
|
|
13947 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13948 uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
|
|
|
13949 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13951
|
|
|
13952 // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html
|
|
|
13953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13954 uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX * pInfo,
|
|
|
13955 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13956 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13957 // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html
|
|
|
13958 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13959 uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info,
|
|
|
13960 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13961 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13962
|
|
|
13963 // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html
|
|
|
13964 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13965 VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( ImageView imageView,
|
|
|
13966 ImageViewAddressPropertiesNVX * pProperties,
|
|
|
13967 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13968 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13969 // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html
|
|
|
13970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13971 VULKAN_HPP_NODISCARD typename ResultValueType<ImageViewAddressPropertiesNVX>::type
|
|
|
13972 getImageViewAddressNVX( ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13973 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
13974
|
|
|
13975 //=== VK_AMD_shader_info ===
|
|
|
13976
|
|
|
13977 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
|
|
|
13978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13979 VULKAN_HPP_NODISCARD Result getShaderInfoAMD( Pipeline pipeline,
|
|
|
13980 ShaderStageFlagBits shaderStage,
|
|
|
13981 ShaderInfoTypeAMD infoType,
|
|
|
13982 size_t * pInfoSize,
|
|
|
13983 void * pInfo,
|
|
|
13984 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
13985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
13986 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
|
|
|
13987 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
13988 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13989 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
13990 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13991 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD(
|
|
|
13992 Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
13993 // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
|
|
|
13994 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
13995 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
13996 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
13997 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
13998 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
|
|
|
13999 getShaderInfoAMD( Pipeline pipeline,
|
|
|
14000 ShaderStageFlagBits shaderStage,
|
|
|
14001 ShaderInfoTypeAMD infoType,
|
|
|
14002 Uint8_tAllocator & uint8_tAllocator,
|
|
|
14003 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14005
|
|
|
14006 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
14007 //=== VK_NV_external_memory_win32 ===
|
|
|
14008
|
|
|
14009 // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html
|
|
|
14010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14011 VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( DeviceMemory memory,
|
|
|
14012 ExternalMemoryHandleTypeFlagsNV handleType,
|
|
|
14013 HANDLE * pHandle,
|
|
|
14014 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14015 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14016 // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html
|
|
|
14017 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14018 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory,
|
|
|
14019 ExternalMemoryHandleTypeFlagsNV handleType,
|
|
|
14020 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14021 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14022 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
14023
|
|
|
14024 //=== VK_KHR_device_group ===
|
|
|
14025
|
|
|
14026 // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see
|
|
|
14027 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html
|
|
|
14028 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14029 void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
|
|
|
14030 uint32_t localDeviceIndex,
|
|
|
14031 uint32_t remoteDeviceIndex,
|
|
|
14032 PeerMemoryFeatureFlags * pPeerMemoryFeatures,
|
|
|
14033 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14035 // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see
|
|
|
14036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html
|
|
|
14037 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14038 VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags
|
|
|
14039 getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
|
|
|
14040 uint32_t localDeviceIndex,
|
|
|
14041 uint32_t remoteDeviceIndex,
|
|
|
14042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14044
|
|
|
14045 //=== VK_KHR_maintenance1 ===
|
|
|
14046
|
|
|
14047 // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html
|
|
|
14048 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14049 void trimCommandPoolKHR( CommandPool commandPool,
|
|
|
14050 CommandPoolTrimFlags flags,
|
|
|
14051 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14052
|
|
|
14053 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
14054 //=== VK_KHR_external_memory_win32 ===
|
|
|
14055
|
|
|
14056 // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html
|
|
|
14057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14058 VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
|
|
|
14059 HANDLE * pHandle,
|
|
|
14060 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14061 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14062 // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html
|
|
|
14063 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14064 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
|
|
|
14065 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14066 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14067
|
|
|
14068 // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see
|
|
|
14069 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html
|
|
|
14070 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14071 VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType,
|
|
|
14072 HANDLE handle,
|
|
|
14073 MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
|
|
|
14074 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14075 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14076 // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see
|
|
|
14077 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html
|
|
|
14078 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14079 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR(
|
|
|
14080 ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14081 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14082 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
14083
|
|
|
14084 //=== VK_KHR_external_memory_fd ===
|
|
|
14085
|
|
|
14086 // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html
|
|
|
14087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14088 VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const MemoryGetFdInfoKHR * pGetFdInfo,
|
|
|
14089 int * pFd,
|
|
|
14090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14092 // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html
|
|
|
14093 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14094 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo,
|
|
|
14095 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14096 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14097
|
|
|
14098 // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html
|
|
|
14099 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14100 VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType,
|
|
|
14101 int fd,
|
|
|
14102 MemoryFdPropertiesKHR * pMemoryFdProperties,
|
|
|
14103 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14104 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14105 // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html
|
|
|
14106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14107 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryFdPropertiesKHR>::type
|
|
|
14108 getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14110
|
|
|
14111 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
14112 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
14113
|
|
|
14114 // wrapper function for command vkImportSemaphoreWin32HandleKHR, see
|
|
|
14115 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html
|
|
|
14116 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14117 VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
|
|
|
14118 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14119 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14120 // wrapper function for command vkImportSemaphoreWin32HandleKHR, see
|
|
|
14121 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html
|
|
|
14122 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14123 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14124 importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
|
|
|
14125 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14126 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14127
|
|
|
14128 // wrapper function for command vkGetSemaphoreWin32HandleKHR, see
|
|
|
14129 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html
|
|
|
14130 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14131 VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
|
|
|
14132 HANDLE * pHandle,
|
|
|
14133 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14134 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14135 // wrapper function for command vkGetSemaphoreWin32HandleKHR, see
|
|
|
14136 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html
|
|
|
14137 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14138 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
|
|
|
14139 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14140 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14141 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
14142
|
|
|
14143 //=== VK_KHR_external_semaphore_fd ===
|
|
|
14144
|
|
|
14145 // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html
|
|
|
14146 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14147 VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
|
|
|
14148 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14149 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14150 // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html
|
|
|
14151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14152 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14153 importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14154 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14155
|
|
|
14156 // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html
|
|
|
14157 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14158 VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR * pGetFdInfo,
|
|
|
14159 int * pFd,
|
|
|
14160 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14161 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14162 // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html
|
|
|
14163 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14164 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo,
|
|
|
14165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14166 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14167
|
|
|
14168 //=== VK_KHR_descriptor_update_template ===
|
|
|
14169
|
|
|
14170 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
|
|
|
14171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
|
|
|
14172 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14173 VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo * pCreateInfo,
|
|
|
14174 const AllocationCallbacks * pAllocator,
|
|
|
14175 DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
|
|
|
14176 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14177 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14178 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
|
|
|
14179 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
|
|
|
14180 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14181 VULKAN_HPP_NODISCARD typename ResultValueType<DescriptorUpdateTemplate>::type
|
|
|
14182 createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo,
|
|
|
14183 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14184 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14185 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
14186 // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see
|
|
|
14187 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html
|
|
|
14188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14189 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate, Dispatch>>::type
|
|
|
14190 createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
|
|
|
14191 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14193 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
14194 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14195
|
|
|
14196 // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see
|
|
|
14197 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html
|
|
|
14198 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14199 void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
14200 const AllocationCallbacks * pAllocator,
|
|
|
14201 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14202 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14203 // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see
|
|
|
14204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html
|
|
|
14205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14206 void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
14207 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14209 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14210
|
|
|
14211 // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see
|
|
|
14212 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html
|
|
|
14213 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14214 void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet,
|
|
|
14215 DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
14216 const void * pData,
|
|
|
14217 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14219 // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see
|
|
|
14220 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html
|
|
|
14221 template <typename DataType,
|
|
|
14222 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14223 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14224 void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet,
|
|
|
14225 DescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
14226 DataType const & data,
|
|
|
14227 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14228 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14229
|
|
|
14230 //=== VK_EXT_display_control ===
|
|
|
14231
|
|
|
14232 // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
|
|
|
14233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14234 VULKAN_HPP_NODISCARD Result displayPowerControlEXT( DisplayKHR display,
|
|
|
14235 const DisplayPowerInfoEXT * pDisplayPowerInfo,
|
|
|
14236 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14237 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14238 // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
|
|
|
14239 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14240 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type displayPowerControlEXT(
|
|
|
14241 DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14242 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14243
|
|
|
14244 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
|
|
|
14245 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14246 VULKAN_HPP_NODISCARD Result registerEventEXT( const DeviceEventInfoEXT * pDeviceEventInfo,
|
|
|
14247 const AllocationCallbacks * pAllocator,
|
|
|
14248 Fence * pFence,
|
|
|
14249 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14250 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14251 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
|
|
|
14252 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14253 VULKAN_HPP_NODISCARD typename ResultValueType<Fence>::type
|
|
|
14254 registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo,
|
|
|
14255 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14257 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
14258 // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
|
|
|
14259 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14260 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
|
|
|
14261 registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo,
|
|
|
14262 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14263 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14264 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
14265 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14266
|
|
|
14267 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
|
|
|
14268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14269 VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( DisplayKHR display,
|
|
|
14270 const DisplayEventInfoEXT * pDisplayEventInfo,
|
|
|
14271 const AllocationCallbacks * pAllocator,
|
|
|
14272 Fence * pFence,
|
|
|
14273 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14274 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14275 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
|
|
|
14276 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14277 VULKAN_HPP_NODISCARD typename ResultValueType<Fence>::type
|
|
|
14278 registerDisplayEventEXT( DisplayKHR display,
|
|
|
14279 const DisplayEventInfoEXT & displayEventInfo,
|
|
|
14280 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14281 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14282 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
14283 // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html
|
|
|
14284 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14285 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Fence, Dispatch>>::type
|
|
|
14286 registerDisplayEventEXTUnique( DisplayKHR display,
|
|
|
14287 const DisplayEventInfoEXT & displayEventInfo,
|
|
|
14288 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14289 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14290 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
14291 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14292
|
|
|
14293 // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html
|
|
|
14294 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14295 VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( SwapchainKHR swapchain,
|
|
|
14296 SurfaceCounterFlagBitsEXT counter,
|
|
|
14297 uint64_t * pCounterValue,
|
|
|
14298 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14299 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14300 // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html
|
|
|
14301 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14302 VULKAN_HPP_NODISCARD
|
|
|
14303 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
|
|
|
14304 ResultValue<uint64_t>
|
|
|
14305 # else
|
|
|
14306 typename ResultValueType<uint64_t>::type
|
|
|
14307 # endif
|
|
|
14308 getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14309 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14310
|
|
|
14311 //=== VK_GOOGLE_display_timing ===
|
|
|
14312
|
|
|
14313 // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see
|
|
|
14314 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html
|
|
|
14315 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14316 VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain,
|
|
|
14317 RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
|
|
|
14318 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14319 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14320 // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see
|
|
|
14321 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html
|
|
|
14322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14323 VULKAN_HPP_NODISCARD typename ResultValueType<RefreshCycleDurationGOOGLE>::type
|
|
|
14324 getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14325 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14326
|
|
|
14327 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
|
|
|
14328 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
|
|
|
14329 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14330 VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain,
|
|
|
14331 uint32_t * pPresentationTimingCount,
|
|
|
14332 PastPresentationTimingGOOGLE * pPresentationTimings,
|
|
|
14333 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14335 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
|
|
|
14336 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
|
|
|
14337 template <
|
|
|
14338 typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
|
|
|
14339 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14340 typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0,
|
|
|
14341 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14342 VULKAN_HPP_NODISCARD
|
|
|
14343 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
|
|
|
14344 ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>
|
|
|
14345 # else
|
|
|
14346 typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
|
|
|
14347 # endif
|
|
|
14348 getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14349 // wrapper function for command vkGetPastPresentationTimingGOOGLE, see
|
|
|
14350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html
|
|
|
14351 template <
|
|
|
14352 typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
|
|
|
14353 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14354 typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0,
|
|
|
14355 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14356 VULKAN_HPP_NODISCARD
|
|
|
14357 # if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
|
|
|
14358 ResultValue<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>
|
|
|
14359 # else
|
|
|
14360 typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
|
|
|
14361 # endif
|
|
|
14362 getPastPresentationTimingGOOGLE( SwapchainKHR swapchain,
|
|
|
14363 PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
|
|
|
14364 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14365 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14366
|
|
|
14367 //=== VK_EXT_hdr_metadata ===
|
|
|
14368
|
|
|
14369 // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html
|
|
|
14370 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14371 void setHdrMetadataEXT( uint32_t swapchainCount,
|
|
|
14372 const SwapchainKHR * pSwapchains,
|
|
|
14373 const HdrMetadataEXT * pMetadata,
|
|
|
14374 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14376 // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html
|
|
|
14377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14378 void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> const & swapchains,
|
|
|
14379 ArrayProxy<const HdrMetadataEXT> const & metadata,
|
|
|
14380 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
14381 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14382
|
|
|
14383 //=== VK_KHR_create_renderpass2 ===
|
|
|
14384
|
|
|
14385 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
|
|
|
14386 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14387 VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const RenderPassCreateInfo2 * pCreateInfo,
|
|
|
14388 const AllocationCallbacks * pAllocator,
|
|
|
14389 RenderPass * pRenderPass,
|
|
|
14390 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14392 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
|
|
|
14393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14394 VULKAN_HPP_NODISCARD typename ResultValueType<RenderPass>::type
|
|
|
14395 createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo,
|
|
|
14396 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14397 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14398 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
14399 // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html
|
|
|
14400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14401 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<RenderPass, Dispatch>>::type
|
|
|
14402 createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo,
|
|
|
14403 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14404 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14405 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
14406 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14407
|
|
|
14408 //=== VK_KHR_shared_presentable_image ===
|
|
|
14409
|
|
|
14410 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14411 // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html
|
|
|
14412 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14413 VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain,
|
|
|
14414 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14415 #else
|
|
|
14416 // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html
|
|
|
14417 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14418 VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14419 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
14420
|
|
|
14421 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
14422 //=== VK_KHR_external_fence_win32 ===
|
|
|
14423
|
|
|
14424 // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html
|
|
|
14425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14426 VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
|
|
|
14427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14428 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14429 // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html
|
|
|
14430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14431 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14432 importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
|
|
|
14433 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14434 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14435
|
|
|
14436 // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html
|
|
|
14437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14438 VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
|
|
|
14439 HANDLE * pHandle,
|
|
|
14440 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14441 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14442 // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html
|
|
|
14443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14444 VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
|
|
|
14445 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14446 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14447 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
14448
|
|
|
14449 //=== VK_KHR_external_fence_fd ===
|
|
|
14450
|
|
|
14451 // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html
|
|
|
14452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14453 VULKAN_HPP_NODISCARD Result importFenceFdKHR( const ImportFenceFdInfoKHR * pImportFenceFdInfo,
|
|
|
14454 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14455 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14456 // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html
|
|
|
14457 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14458 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14459 importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14460 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14461
|
|
|
14462 // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html
|
|
|
14463 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14464 VULKAN_HPP_NODISCARD Result getFenceFdKHR( const FenceGetFdInfoKHR * pGetFdInfo,
|
|
|
14465 int * pFd,
|
|
|
14466 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14467 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14468 // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html
|
|
|
14469 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14470 VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo,
|
|
|
14471 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14472 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14473
|
|
|
14474 //=== VK_KHR_performance_query ===
|
|
|
14475
|
|
|
14476 // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html
|
|
|
14477 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14478 VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR * pInfo,
|
|
|
14479 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14481 // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html
|
|
|
14482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14483 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14484 acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14485 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14486
|
|
|
14487 // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html
|
|
|
14488 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14489 void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14490
|
|
|
14491 //=== VK_EXT_debug_utils ===
|
|
|
14492
|
|
|
14493 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see
|
|
|
14494 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
|
|
|
14495 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14496 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT * pNameInfo,
|
|
|
14497 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14499 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see
|
|
|
14500 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
|
|
|
14501 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14502 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14503 setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14504 // wrapper function for command vkSetDebugUtilsObjectNameEXT, see
|
|
|
14505 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html
|
|
|
14506 template <typename HandleType,
|
|
|
14507 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14508 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14509 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14510 setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14511 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14512
|
|
|
14513 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
|
|
|
14514 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14515 VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT * pTagInfo,
|
|
|
14516 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14518 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
|
|
|
14519 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14520 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
14521 setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14522 // wrapper function for command vkSetDebugUtilsObjectTagEXT, see
|
|
|
14523 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html
|
|
|
14524 template <typename HandleType,
|
|
|
14525 typename TagType,
|
|
|
14526 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14527 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14528 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectTagEXT(
|
|
|
14529 HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14530 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14531
|
|
|
14532 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
14533 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
14534
|
|
|
14535 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
|
|
|
14536 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
|
|
|
14537 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14538 VULKAN_HPP_NODISCARD Result
|
|
|
14539 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer,
|
|
|
14540 AndroidHardwareBufferPropertiesANDROID * pProperties,
|
|
|
14541 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14542 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14543 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
|
|
|
14544 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
|
|
|
14545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14546 VULKAN_HPP_NODISCARD typename ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type
|
|
|
14547 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14548 // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see
|
|
|
14549 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html
|
|
|
14550 template <typename X,
|
|
|
14551 typename Y,
|
|
|
14552 typename... Z,
|
|
|
14553 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14554 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14555 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
14556 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14557 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14558
|
|
|
14559 // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see
|
|
|
14560 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html
|
|
|
14561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14562 VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
|
|
|
14563 struct AHardwareBuffer ** pBuffer,
|
|
|
14564 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14565 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14566 // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see
|
|
|
14567 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html
|
|
|
14568 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14569 VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type
|
|
|
14570 getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
|
|
|
14571 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14572 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14573 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
14574
|
|
|
14575 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
14576 //=== VK_AMDX_shader_enqueue ===
|
|
|
14577
|
|
|
14578 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
|
|
|
14579 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
|
|
|
14580 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14581 VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
|
|
|
14582 uint32_t createInfoCount,
|
|
|
14583 const ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
|
|
|
14584 const AllocationCallbacks * pAllocator,
|
|
|
14585 Pipeline * pPipelines,
|
|
|
14586 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14587 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14588 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
|
|
|
14589 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
|
|
|
14590 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
14591 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14592 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
14593 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14594 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
14595 createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
|
|
|
14596 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
|
|
|
14597 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14598 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14599 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
|
|
|
14600 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
|
|
|
14601 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
14602 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14603 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
14604 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14605 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
14606 createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache,
|
|
|
14607 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
|
|
|
14608 Optional<const AllocationCallbacks> allocator,
|
|
|
14609 PipelineAllocator & pipelineAllocator,
|
|
|
14610 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14611 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
|
|
|
14612 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
|
|
|
14613 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14614 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
|
|
|
14615 createExecutionGraphPipelineAMDX( PipelineCache pipelineCache,
|
|
|
14616 const ExecutionGraphPipelineCreateInfoAMDX & createInfo,
|
|
|
14617 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14618 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14619 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
14620 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
|
|
|
14621 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
|
|
|
14622 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14623 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
14624 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
14625 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14626 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
14627 createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache,
|
|
|
14628 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
|
|
|
14629 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14630 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14631 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
|
|
|
14632 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
|
|
|
14633 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14634 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
14635 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
14636 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14637 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
14638 createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache,
|
|
|
14639 ArrayProxy<const ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
|
|
|
14640 Optional<const AllocationCallbacks> allocator,
|
|
|
14641 PipelineAllocator & pipelineAllocator,
|
|
|
14642 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14643 // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see
|
|
|
14644 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html
|
|
|
14645 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14646 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
|
|
|
14647 createExecutionGraphPipelineAMDXUnique( PipelineCache pipelineCache,
|
|
|
14648 const ExecutionGraphPipelineCreateInfoAMDX & createInfo,
|
|
|
14649 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14650 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14651 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
14652 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14653
|
|
|
14654 // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see
|
|
|
14655 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html
|
|
|
14656 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14657 VULKAN_HPP_NODISCARD Result
|
|
|
14658 getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph,
|
|
|
14659 ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,
|
|
|
14660 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14661 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14662 // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see
|
|
|
14663 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html
|
|
|
14664 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14665 VULKAN_HPP_NODISCARD typename ResultValueType<ExecutionGraphPipelineScratchSizeAMDX>::type
|
|
|
14666 getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14667 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14668
|
|
|
14669 // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see
|
|
|
14670 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html
|
|
|
14671 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14672 VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph,
|
|
|
14673 const PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
|
|
|
14674 uint32_t * pNodeIndex,
|
|
|
14675 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14676 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14677 // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see
|
|
|
14678 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html
|
|
|
14679 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14680 VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type getExecutionGraphPipelineNodeIndexAMDX(
|
|
|
14681 Pipeline executionGraph, const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14682 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14683 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
14684
|
|
|
14685 //=== VK_KHR_get_memory_requirements2 ===
|
|
|
14686
|
|
|
14687 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
|
|
|
14688 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
|
|
|
14689 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14690 void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 * pInfo,
|
|
|
14691 MemoryRequirements2 * pMemoryRequirements,
|
|
|
14692 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14694 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
|
|
|
14695 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
|
|
|
14696 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14697 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2KHR(
|
|
|
14698 const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14699 // wrapper function for command vkGetImageMemoryRequirements2KHR, see
|
|
|
14700 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html
|
|
|
14701 template <typename X,
|
|
|
14702 typename Y,
|
|
|
14703 typename... Z,
|
|
|
14704 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14705 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14706 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
14707 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info,
|
|
|
14708 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14709 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14710
|
|
|
14711 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
|
|
|
14712 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
|
|
|
14713 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14714 void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 * pInfo,
|
|
|
14715 MemoryRequirements2 * pMemoryRequirements,
|
|
|
14716 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14718 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
|
|
|
14719 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
|
|
|
14720 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14721 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2KHR(
|
|
|
14722 const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14723 // wrapper function for command vkGetBufferMemoryRequirements2KHR, see
|
|
|
14724 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html
|
|
|
14725 template <typename X,
|
|
|
14726 typename Y,
|
|
|
14727 typename... Z,
|
|
|
14728 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14729 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14730 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
14731 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info,
|
|
|
14732 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14734
|
|
|
14735 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
|
|
|
14736 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
|
|
|
14737 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14738 void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 * pInfo,
|
|
|
14739 uint32_t * pSparseMemoryRequirementCount,
|
|
|
14740 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
|
|
|
14741 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14742 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14743 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
|
|
|
14744 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
|
|
|
14745 template <
|
|
|
14746 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
14747 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14748 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
14749 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14750 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
14751 getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
|
|
|
14752 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14753 // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see
|
|
|
14754 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html
|
|
|
14755 template <
|
|
|
14756 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
14757 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14758 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
14759 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14760 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
14761 getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
|
|
|
14762 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
|
|
|
14763 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14765
|
|
|
14766 //=== VK_KHR_acceleration_structure ===
|
|
|
14767
|
|
|
14768 // wrapper function for command vkCreateAccelerationStructureKHR, see
|
|
|
14769 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
|
|
|
14770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14771 VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR * pCreateInfo,
|
|
|
14772 const AllocationCallbacks * pAllocator,
|
|
|
14773 AccelerationStructureKHR * pAccelerationStructure,
|
|
|
14774 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14776 // wrapper function for command vkCreateAccelerationStructureKHR, see
|
|
|
14777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
|
|
|
14778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14779 VULKAN_HPP_NODISCARD typename ResultValueType<AccelerationStructureKHR>::type
|
|
|
14780 createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
|
|
|
14781 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14782 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14783 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
14784 // wrapper function for command vkCreateAccelerationStructureKHR, see
|
|
|
14785 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html
|
|
|
14786 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14787 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<AccelerationStructureKHR, Dispatch>>::type
|
|
|
14788 createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
|
|
|
14789 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14790 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14791 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
14792 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14793
|
|
|
14794 // wrapper function for command vkDestroyAccelerationStructureKHR, see
|
|
|
14795 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
|
|
|
14796 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14797 void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure,
|
|
|
14798 const AllocationCallbacks * pAllocator,
|
|
|
14799 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14800 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14801 // wrapper function for command vkDestroyAccelerationStructureKHR, see
|
|
|
14802 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
|
|
|
14803 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14804 void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
14805 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14806 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14808
|
|
|
14809 // wrapper function for command vkDestroyAccelerationStructureKHR, see
|
|
|
14810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
|
|
|
14811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14812 void destroy( AccelerationStructureKHR accelerationStructure,
|
|
|
14813 const AllocationCallbacks * pAllocator,
|
|
|
14814 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14815 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14816 // wrapper function for command vkDestroyAccelerationStructureKHR, see
|
|
|
14817 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html
|
|
|
14818 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14819 void destroy( AccelerationStructureKHR accelerationStructure,
|
|
|
14820 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14821 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14822 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14823
|
|
|
14824 // wrapper function for command vkBuildAccelerationStructuresKHR, see
|
|
|
14825 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html
|
|
|
14826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14827 VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation,
|
|
|
14828 uint32_t infoCount,
|
|
|
14829 const AccelerationStructureBuildGeometryInfoKHR * pInfos,
|
|
|
14830 const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
|
|
|
14831 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14833 // wrapper function for command vkBuildAccelerationStructuresKHR, see
|
|
|
14834 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html
|
|
|
14835 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14836 VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation,
|
|
|
14837 ArrayProxy<const AccelerationStructureBuildGeometryInfoKHR> const & infos,
|
|
|
14838 ArrayProxy<const AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
|
|
|
14839 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14840 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14841
|
|
|
14842 // wrapper function for command vkCopyAccelerationStructureKHR, see
|
|
|
14843 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html
|
|
|
14844 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14845 VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
|
|
|
14846 const CopyAccelerationStructureInfoKHR * pInfo,
|
|
|
14847 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14849 // wrapper function for command vkCopyAccelerationStructureKHR, see
|
|
|
14850 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html
|
|
|
14851 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14852 VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
|
|
|
14853 const CopyAccelerationStructureInfoKHR & info,
|
|
|
14854 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14855 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14856
|
|
|
14857 // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see
|
|
|
14858 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html
|
|
|
14859 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14860 VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation,
|
|
|
14861 const CopyAccelerationStructureToMemoryInfoKHR * pInfo,
|
|
|
14862 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14863 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14864 // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see
|
|
|
14865 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html
|
|
|
14866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14867 VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation,
|
|
|
14868 const CopyAccelerationStructureToMemoryInfoKHR & info,
|
|
|
14869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14870 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14871
|
|
|
14872 // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see
|
|
|
14873 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html
|
|
|
14874 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14875 VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
|
|
|
14876 const CopyMemoryToAccelerationStructureInfoKHR * pInfo,
|
|
|
14877 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14879 // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see
|
|
|
14880 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html
|
|
|
14881 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14882 VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation,
|
|
|
14883 const CopyMemoryToAccelerationStructureInfoKHR & info,
|
|
|
14884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14885 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14886
|
|
|
14887 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
|
|
|
14888 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
|
|
|
14889 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14890 VULKAN_HPP_NODISCARD Result
|
|
|
14891 writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
|
|
|
14892 const AccelerationStructureKHR * pAccelerationStructures,
|
|
|
14893 QueryType queryType,
|
|
|
14894 size_t dataSize,
|
|
|
14895 void * pData,
|
|
|
14896 size_t stride,
|
|
|
14897 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14899 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
|
|
|
14900 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
|
|
|
14901 template <typename DataType,
|
|
|
14902 typename DataTypeAllocator = std::allocator<DataType>,
|
|
|
14903 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14904 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
|
|
|
14905 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14906 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
|
|
|
14907 writeAccelerationStructuresPropertiesKHR( ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures,
|
|
|
14908 QueryType queryType,
|
|
|
14909 size_t dataSize,
|
|
|
14910 size_t stride,
|
|
|
14911 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14912 // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see
|
|
|
14913 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html
|
|
|
14914 template <typename DataType,
|
|
|
14915 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14916 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14917 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
14918 writeAccelerationStructuresPropertyKHR( ArrayProxy<const AccelerationStructureKHR> const & accelerationStructures,
|
|
|
14919 QueryType queryType,
|
|
|
14920 size_t stride,
|
|
|
14921 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14922 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14923
|
|
|
14924 // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see
|
|
|
14925 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html
|
|
|
14926 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14927 DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR * pInfo,
|
|
|
14928 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14929 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14930 // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see
|
|
|
14931 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html
|
|
|
14932 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14933 DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info,
|
|
|
14934 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14935 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14936
|
|
|
14937 // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see
|
|
|
14938 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html
|
|
|
14939 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14940 void getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR * pVersionInfo,
|
|
|
14941 AccelerationStructureCompatibilityKHR * pCompatibility,
|
|
|
14942 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14944 // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see
|
|
|
14945 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html
|
|
|
14946 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14947 VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR(
|
|
|
14948 const AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14949 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14950
|
|
|
14951 // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see
|
|
|
14952 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html
|
|
|
14953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14954 void getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType,
|
|
|
14955 const AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
|
|
|
14956 const uint32_t * pMaxPrimitiveCounts,
|
|
|
14957 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
|
|
|
14958 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14959 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14960 // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see
|
|
|
14961 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html
|
|
|
14962 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14963 VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR
|
|
|
14964 getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType,
|
|
|
14965 const AccelerationStructureBuildGeometryInfoKHR & buildInfo,
|
|
|
14966 ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14967 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
|
|
|
14968 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
14969
|
|
|
14970 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
14971
|
|
|
14972 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
|
|
|
14973 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
|
|
|
14974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14975 VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
|
|
|
14976 PipelineCache pipelineCache,
|
|
|
14977 uint32_t createInfoCount,
|
|
|
14978 const RayTracingPipelineCreateInfoKHR * pCreateInfos,
|
|
|
14979 const AllocationCallbacks * pAllocator,
|
|
|
14980 Pipeline * pPipelines,
|
|
|
14981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
14982 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
14983 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
|
|
|
14984 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
|
|
|
14985 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
14986 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14987 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
14988 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
14989 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
14990 createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
|
|
|
14991 PipelineCache pipelineCache,
|
|
|
14992 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
|
|
|
14993 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
14994 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
14995 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
|
|
|
14996 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
|
|
|
14997 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
14998 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
14999 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
15000 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15001 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
15002 createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation,
|
|
|
15003 PipelineCache pipelineCache,
|
|
|
15004 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
|
|
|
15005 Optional<const AllocationCallbacks> allocator,
|
|
|
15006 PipelineAllocator & pipelineAllocator,
|
|
|
15007 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15008 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
|
|
|
15009 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
|
|
|
15010 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15011 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
|
|
|
15012 createRayTracingPipelineKHR( DeferredOperationKHR deferredOperation,
|
|
|
15013 PipelineCache pipelineCache,
|
|
|
15014 const RayTracingPipelineCreateInfoKHR & createInfo,
|
|
|
15015 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15016 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15017 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
15018 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
|
|
|
15019 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
|
|
|
15020 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15021 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
15022 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
15023 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15024 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
15025 createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation,
|
|
|
15026 PipelineCache pipelineCache,
|
|
|
15027 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
|
|
|
15028 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15030 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
|
|
|
15031 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
|
|
|
15032 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15033 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
15034 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
15035 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15036 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
15037 createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation,
|
|
|
15038 PipelineCache pipelineCache,
|
|
|
15039 ArrayProxy<const RayTracingPipelineCreateInfoKHR> const & createInfos,
|
|
|
15040 Optional<const AllocationCallbacks> allocator,
|
|
|
15041 PipelineAllocator & pipelineAllocator,
|
|
|
15042 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15043 // wrapper function for command vkCreateRayTracingPipelinesKHR, see
|
|
|
15044 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html
|
|
|
15045 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15046 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
|
|
|
15047 createRayTracingPipelineKHRUnique( DeferredOperationKHR deferredOperation,
|
|
|
15048 PipelineCache pipelineCache,
|
|
|
15049 const RayTracingPipelineCreateInfoKHR & createInfo,
|
|
|
15050 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15051 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15052 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
15053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15054
|
|
|
15055 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
|
|
|
15056 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
|
|
|
15057 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15058 VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( Pipeline pipeline,
|
|
|
15059 uint32_t firstGroup,
|
|
|
15060 uint32_t groupCount,
|
|
|
15061 size_t dataSize,
|
|
|
15062 void * pData,
|
|
|
15063 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15065 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
|
|
|
15066 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
|
|
|
15067 template <typename DataType,
|
|
|
15068 typename DataTypeAllocator = std::allocator<DataType>,
|
|
|
15069 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15070 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
|
|
|
15071 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15072 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesKHR(
|
|
|
15073 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15074 // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see
|
|
|
15075 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html
|
|
|
15076 template <typename DataType,
|
|
|
15077 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15078 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15079 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR(
|
|
|
15080 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15081 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15082
|
|
|
15083 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
|
|
|
15084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
|
|
|
15085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15086 VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(
|
|
|
15087 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
|
|
|
15088 const VULKAN_HPP_NOEXCEPT;
|
|
|
15089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15090 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
|
|
|
15091 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
|
|
|
15092 template <typename DataType,
|
|
|
15093 typename DataTypeAllocator = std::allocator<DataType>,
|
|
|
15094 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15095 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
|
|
|
15096 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15097 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingCaptureReplayShaderGroupHandlesKHR(
|
|
|
15098 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15099 // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see
|
|
|
15100 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html
|
|
|
15101 template <typename DataType,
|
|
|
15102 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15103 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15104 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR(
|
|
|
15105 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15106 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15107
|
|
|
15108 // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see
|
|
|
15109 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html
|
|
|
15110 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15111 DeviceSize getRayTracingShaderGroupStackSizeKHR( Pipeline pipeline,
|
|
|
15112 uint32_t group,
|
|
|
15113 ShaderGroupShaderKHR groupShader,
|
|
|
15114 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15115
|
|
|
15116 //=== VK_KHR_sampler_ycbcr_conversion ===
|
|
|
15117
|
|
|
15118 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
|
|
|
15119 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
|
|
|
15120 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15121 VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo * pCreateInfo,
|
|
|
15122 const AllocationCallbacks * pAllocator,
|
|
|
15123 SamplerYcbcrConversion * pYcbcrConversion,
|
|
|
15124 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15126 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
|
|
|
15127 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
|
|
|
15128 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15129 VULKAN_HPP_NODISCARD typename ResultValueType<SamplerYcbcrConversion>::type
|
|
|
15130 createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
|
|
|
15131 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15132 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15133 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
15134 // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see
|
|
|
15135 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html
|
|
|
15136 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15137 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SamplerYcbcrConversion, Dispatch>>::type
|
|
|
15138 createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
|
|
|
15139 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15140 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15141 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
15142 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15143
|
|
|
15144 // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see
|
|
|
15145 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html
|
|
|
15146 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15147 void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion,
|
|
|
15148 const AllocationCallbacks * pAllocator,
|
|
|
15149 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15150 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15151 // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see
|
|
|
15152 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html
|
|
|
15153 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15154 void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
15155 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15156 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15157 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15158
|
|
|
15159 //=== VK_KHR_bind_memory2 ===
|
|
|
15160
|
|
|
15161 // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html
|
|
|
15162 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15163 VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount,
|
|
|
15164 const BindBufferMemoryInfo * pBindInfos,
|
|
|
15165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15167 // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html
|
|
|
15168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15169 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15170 bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15171 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15172
|
|
|
15173 // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html
|
|
|
15174 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15175 VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount,
|
|
|
15176 const BindImageMemoryInfo * pBindInfos,
|
|
|
15177 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15178 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15179 // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html
|
|
|
15180 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15181 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15182 bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15183 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15184
|
|
|
15185 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
15186
|
|
|
15187 // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see
|
|
|
15188 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html
|
|
|
15189 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15190 VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( Image image,
|
|
|
15191 ImageDrmFormatModifierPropertiesEXT * pProperties,
|
|
|
15192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15194 // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see
|
|
|
15195 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html
|
|
|
15196 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15197 VULKAN_HPP_NODISCARD typename ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type
|
|
|
15198 getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15200
|
|
|
15201 //=== VK_EXT_validation_cache ===
|
|
|
15202
|
|
|
15203 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
|
|
|
15204 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15205 VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT * pCreateInfo,
|
|
|
15206 const AllocationCallbacks * pAllocator,
|
|
|
15207 ValidationCacheEXT * pValidationCache,
|
|
|
15208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15209 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15210 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
|
|
|
15211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15212 VULKAN_HPP_NODISCARD typename ResultValueType<ValidationCacheEXT>::type
|
|
|
15213 createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo,
|
|
|
15214 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15215 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15216 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
15217 // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html
|
|
|
15218 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15219 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ValidationCacheEXT, Dispatch>>::type
|
|
|
15220 createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
|
|
|
15221 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15222 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15223 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
15224 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15225
|
|
|
15226 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
|
|
|
15227 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15228 void destroyValidationCacheEXT( ValidationCacheEXT validationCache,
|
|
|
15229 const AllocationCallbacks * pAllocator,
|
|
|
15230 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15232 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
|
|
|
15233 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15234 void destroyValidationCacheEXT( ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
15235 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15236 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15238
|
|
|
15239 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
|
|
|
15240 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15241 void destroy( ValidationCacheEXT validationCache,
|
|
|
15242 const AllocationCallbacks * pAllocator,
|
|
|
15243 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15244 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15245 // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html
|
|
|
15246 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15247 void destroy( ValidationCacheEXT validationCache,
|
|
|
15248 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15249 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15250 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15251
|
|
|
15252 // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html
|
|
|
15253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15254 VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( ValidationCacheEXT dstCache,
|
|
|
15255 uint32_t srcCacheCount,
|
|
|
15256 const ValidationCacheEXT * pSrcCaches,
|
|
|
15257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15258 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15259 // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html
|
|
|
15260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15261 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergeValidationCachesEXT(
|
|
|
15262 ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15264
|
|
|
15265 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
|
|
|
15266 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15267 VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( ValidationCacheEXT validationCache,
|
|
|
15268 size_t * pDataSize,
|
|
|
15269 void * pData,
|
|
|
15270 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15272 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
|
|
|
15273 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
15274 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15275 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
15276 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15277 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
|
|
|
15278 getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15279 // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html
|
|
|
15280 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
15281 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15282 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
15283 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15284 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT(
|
|
|
15285 ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15287
|
|
|
15288 //=== VK_NV_ray_tracing ===
|
|
|
15289
|
|
|
15290 // wrapper function for command vkCreateAccelerationStructureNV, see
|
|
|
15291 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
|
|
|
15292 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15293 VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV * pCreateInfo,
|
|
|
15294 const AllocationCallbacks * pAllocator,
|
|
|
15295 AccelerationStructureNV * pAccelerationStructure,
|
|
|
15296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15298 // wrapper function for command vkCreateAccelerationStructureNV, see
|
|
|
15299 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
|
|
|
15300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15301 VULKAN_HPP_NODISCARD typename ResultValueType<AccelerationStructureNV>::type
|
|
|
15302 createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo,
|
|
|
15303 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15304 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15305 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
15306 // wrapper function for command vkCreateAccelerationStructureNV, see
|
|
|
15307 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html
|
|
|
15308 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15309 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<AccelerationStructureNV, Dispatch>>::type
|
|
|
15310 createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
|
|
|
15311 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15312 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15313 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
15314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15315
|
|
|
15316 // wrapper function for command vkDestroyAccelerationStructureNV, see
|
|
|
15317 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
|
|
|
15318 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15319 void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure,
|
|
|
15320 const AllocationCallbacks * pAllocator,
|
|
|
15321 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15322 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15323 // wrapper function for command vkDestroyAccelerationStructureNV, see
|
|
|
15324 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
|
|
|
15325 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15326 void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
15327 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15328 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15329 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15330
|
|
|
15331 // wrapper function for command vkDestroyAccelerationStructureNV, see
|
|
|
15332 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
|
|
|
15333 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15334 void destroy( AccelerationStructureNV accelerationStructure,
|
|
|
15335 const AllocationCallbacks * pAllocator,
|
|
|
15336 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15337 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15338 // wrapper function for command vkDestroyAccelerationStructureNV, see
|
|
|
15339 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html
|
|
|
15340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15341 void destroy( AccelerationStructureNV accelerationStructure,
|
|
|
15342 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15343 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15344 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15345
|
|
|
15346 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
|
|
|
15347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
|
|
|
15348 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15349 void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV * pInfo,
|
|
|
15350 MemoryRequirements2KHR * pMemoryRequirements,
|
|
|
15351 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15353 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
|
|
|
15354 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
|
|
|
15355 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15356 VULKAN_HPP_NODISCARD MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
|
|
|
15357 const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15358 // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see
|
|
|
15359 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html
|
|
|
15360 template <typename X,
|
|
|
15361 typename Y,
|
|
|
15362 typename... Z,
|
|
|
15363 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15364 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15365 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
15366 getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info,
|
|
|
15367 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15368 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15369
|
|
|
15370 // wrapper function for command vkBindAccelerationStructureMemoryNV, see
|
|
|
15371 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html
|
|
|
15372 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15373 VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount,
|
|
|
15374 const BindAccelerationStructureMemoryInfoNV * pBindInfos,
|
|
|
15375 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15377 // wrapper function for command vkBindAccelerationStructureMemoryNV, see
|
|
|
15378 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html
|
|
|
15379 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15380 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15381 bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> const & bindInfos,
|
|
|
15382 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15383 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15384
|
|
|
15385 // wrapper function for command vkCreateRayTracingPipelinesNV, see
|
|
|
15386 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
|
|
|
15387 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15388 VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( PipelineCache pipelineCache,
|
|
|
15389 uint32_t createInfoCount,
|
|
|
15390 const RayTracingPipelineCreateInfoNV * pCreateInfos,
|
|
|
15391 const AllocationCallbacks * pAllocator,
|
|
|
15392 Pipeline * pPipelines,
|
|
|
15393 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15395 // wrapper function for command vkCreateRayTracingPipelinesNV, see
|
|
|
15396 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
|
|
|
15397 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
15398 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15399 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
15400 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15401 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
15402 createRayTracingPipelinesNV( PipelineCache pipelineCache,
|
|
|
15403 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
|
|
|
15404 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15405 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15406 // wrapper function for command vkCreateRayTracingPipelinesNV, see
|
|
|
15407 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
|
|
|
15408 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
15409 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15410 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
15411 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15412 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
15413 createRayTracingPipelinesNV( PipelineCache pipelineCache,
|
|
|
15414 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
|
|
|
15415 Optional<const AllocationCallbacks> allocator,
|
|
|
15416 PipelineAllocator & pipelineAllocator,
|
|
|
15417 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15418 // wrapper function for command vkCreateRayTracingPipelinesNV, see
|
|
|
15419 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
|
|
|
15420 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15421 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
|
|
|
15422 createRayTracingPipelineNV( PipelineCache pipelineCache,
|
|
|
15423 const RayTracingPipelineCreateInfoNV & createInfo,
|
|
|
15424 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15425 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15426 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
15427 // wrapper function for command vkCreateRayTracingPipelinesNV, see
|
|
|
15428 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
|
|
|
15429 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15430 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
15431 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
15432 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15433 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
15434 createRayTracingPipelinesNVUnique( PipelineCache pipelineCache,
|
|
|
15435 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
|
|
|
15436 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15437 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15438 // wrapper function for command vkCreateRayTracingPipelinesNV, see
|
|
|
15439 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
|
|
|
15440 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15441 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
15442 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
15443 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15444 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
15445 createRayTracingPipelinesNVUnique( PipelineCache pipelineCache,
|
|
|
15446 ArrayProxy<const RayTracingPipelineCreateInfoNV> const & createInfos,
|
|
|
15447 Optional<const AllocationCallbacks> allocator,
|
|
|
15448 PipelineAllocator & pipelineAllocator,
|
|
|
15449 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15450 // wrapper function for command vkCreateRayTracingPipelinesNV, see
|
|
|
15451 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html
|
|
|
15452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15453 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
|
|
|
15454 createRayTracingPipelineNVUnique( PipelineCache pipelineCache,
|
|
|
15455 const RayTracingPipelineCreateInfoNV & createInfo,
|
|
|
15456 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15457 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15458 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
15459 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15460
|
|
|
15461 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
|
|
|
15462 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
|
|
|
15463 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15464 VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline,
|
|
|
15465 uint32_t firstGroup,
|
|
|
15466 uint32_t groupCount,
|
|
|
15467 size_t dataSize,
|
|
|
15468 void * pData,
|
|
|
15469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15471 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
|
|
|
15472 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
|
|
|
15473 template <typename DataType,
|
|
|
15474 typename DataTypeAllocator = std::allocator<DataType>,
|
|
|
15475 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15476 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
|
|
|
15477 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15478 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesNV(
|
|
|
15479 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15480 // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see
|
|
|
15481 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html
|
|
|
15482 template <typename DataType,
|
|
|
15483 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15484 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15485 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV(
|
|
|
15486 Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15487 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15488
|
|
|
15489 // wrapper function for command vkGetAccelerationStructureHandleNV, see
|
|
|
15490 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
|
|
|
15491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15492 VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure,
|
|
|
15493 size_t dataSize,
|
|
|
15494 void * pData,
|
|
|
15495 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15497 // wrapper function for command vkGetAccelerationStructureHandleNV, see
|
|
|
15498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
|
|
|
15499 template <typename DataType,
|
|
|
15500 typename DataTypeAllocator = std::allocator<DataType>,
|
|
|
15501 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15502 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
|
|
|
15503 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15504 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(
|
|
|
15505 AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15506 // wrapper function for command vkGetAccelerationStructureHandleNV, see
|
|
|
15507 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html
|
|
|
15508 template <typename DataType,
|
|
|
15509 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15510 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15511 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
15512 getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15513 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15514
|
|
|
15515 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15516 // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html
|
|
|
15517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15518 VULKAN_HPP_NODISCARD Result compileDeferredNV( Pipeline pipeline,
|
|
|
15519 uint32_t shader,
|
|
|
15520 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15521 #else
|
|
|
15522 // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html
|
|
|
15523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15524 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15525 compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15526 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15527
|
|
|
15528 //=== VK_KHR_maintenance3 ===
|
|
|
15529
|
|
|
15530 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
|
|
|
15531 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
|
|
|
15532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15533 void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo * pCreateInfo,
|
|
|
15534 DescriptorSetLayoutSupport * pSupport,
|
|
|
15535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15537 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
|
|
|
15538 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
|
|
|
15539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15540 VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
|
|
|
15541 const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15542 // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see
|
|
|
15543 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html
|
|
|
15544 template <typename X,
|
|
|
15545 typename Y,
|
|
|
15546 typename... Z,
|
|
|
15547 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15548 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15549 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
15550 getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo,
|
|
|
15551 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15553
|
|
|
15554 //=== VK_EXT_external_memory_host ===
|
|
|
15555
|
|
|
15556 // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see
|
|
|
15557 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html
|
|
|
15558 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15559 VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType,
|
|
|
15560 const void * pHostPointer,
|
|
|
15561 MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
|
|
|
15562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15564 // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see
|
|
|
15565 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html
|
|
|
15566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15567 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT(
|
|
|
15568 ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15570
|
|
|
15571 //=== VK_EXT_calibrated_timestamps ===
|
|
|
15572
|
|
|
15573 // wrapper function for command vkGetCalibratedTimestampsEXT, see
|
|
|
15574 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
|
|
|
15575 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15576 VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount,
|
|
|
15577 const CalibratedTimestampInfoKHR * pTimestampInfos,
|
|
|
15578 uint64_t * pTimestamps,
|
|
|
15579 uint64_t * pMaxDeviation,
|
|
|
15580 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15581 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15582 // wrapper function for command vkGetCalibratedTimestampsEXT, see
|
|
|
15583 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
|
|
|
15584 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
|
|
|
15585 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15586 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
|
|
|
15587 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15588 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
|
|
15589 getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
|
|
|
15590 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15591 // wrapper function for command vkGetCalibratedTimestampsEXT, see
|
|
|
15592 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
|
|
|
15593 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
|
|
|
15594 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15595 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
|
|
|
15596 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15597 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
|
|
15598 getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
|
|
|
15599 Uint64_tAllocator & uint64_tAllocator,
|
|
|
15600 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15601 // wrapper function for command vkGetCalibratedTimestampsEXT, see
|
|
|
15602 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html
|
|
|
15603 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15604 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
|
|
|
15605 getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15606 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15607
|
|
|
15608 //=== VK_KHR_timeline_semaphore ===
|
|
|
15609
|
|
|
15610 // wrapper function for command vkGetSemaphoreCounterValueKHR, see
|
|
|
15611 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html
|
|
|
15612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15613 VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( Semaphore semaphore,
|
|
|
15614 uint64_t * pValue,
|
|
|
15615 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15616 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15617 // wrapper function for command vkGetSemaphoreCounterValueKHR, see
|
|
|
15618 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html
|
|
|
15619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15620 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
|
|
|
15621 getSemaphoreCounterValueKHR( Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15622 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15623
|
|
|
15624 // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html
|
|
|
15625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15626 VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo * pWaitInfo,
|
|
|
15627 uint64_t timeout,
|
|
|
15628 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15629 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15630 // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html
|
|
|
15631 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15632 VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
|
|
|
15633 uint64_t timeout,
|
|
|
15634 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15635 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15636
|
|
|
15637 // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html
|
|
|
15638 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15639 VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const SemaphoreSignalInfo * pSignalInfo,
|
|
|
15640 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15642 // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html
|
|
|
15643 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15644 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15645 signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15646 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15647
|
|
|
15648 //=== VK_INTEL_performance_query ===
|
|
|
15649
|
|
|
15650 // wrapper function for command vkInitializePerformanceApiINTEL, see
|
|
|
15651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html
|
|
|
15652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15653 VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL * pInitializeInfo,
|
|
|
15654 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15656 // wrapper function for command vkInitializePerformanceApiINTEL, see
|
|
|
15657 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html
|
|
|
15658 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15659 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15660 initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
|
|
|
15661 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15662 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15663
|
|
|
15664 // wrapper function for command vkUninitializePerformanceApiINTEL, see
|
|
|
15665 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html
|
|
|
15666 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15667 void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15668
|
|
|
15669 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
|
|
|
15670 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
|
|
|
15671 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15672 VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
|
|
|
15673 PerformanceConfigurationINTEL * pConfiguration,
|
|
|
15674 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15675 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15676 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
|
|
|
15677 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
|
|
|
15678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15679 VULKAN_HPP_NODISCARD typename ResultValueType<PerformanceConfigurationINTEL>::type
|
|
|
15680 acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
|
|
|
15681 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15682 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
15683 // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see
|
|
|
15684 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html
|
|
|
15685 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15686 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PerformanceConfigurationINTEL, Dispatch>>::type
|
|
|
15687 acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
|
|
|
15688 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15689 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
15690 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15691
|
|
|
15692 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15693 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
|
|
|
15694 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
|
|
|
15695 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15696 VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration,
|
|
|
15697 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15698 #else
|
|
|
15699 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
|
|
|
15700 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
|
|
|
15701 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15702 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15703 releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
15704 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15705 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15706
|
|
|
15707 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15708 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
|
|
|
15709 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
|
|
|
15710 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15711 VULKAN_HPP_NODISCARD Result release( PerformanceConfigurationINTEL configuration,
|
|
|
15712 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15713 #else
|
|
|
15714 // wrapper function for command vkReleasePerformanceConfigurationINTEL, see
|
|
|
15715 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html
|
|
|
15716 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15717 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( PerformanceConfigurationINTEL configuration,
|
|
|
15718 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15719 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15720
|
|
|
15721 // wrapper function for command vkGetPerformanceParameterINTEL, see
|
|
|
15722 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html
|
|
|
15723 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15724 VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter,
|
|
|
15725 PerformanceValueINTEL * pValue,
|
|
|
15726 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15727 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15728 // wrapper function for command vkGetPerformanceParameterINTEL, see
|
|
|
15729 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html
|
|
|
15730 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15731 VULKAN_HPP_NODISCARD typename ResultValueType<PerformanceValueINTEL>::type
|
|
|
15732 getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15734
|
|
|
15735 //=== VK_AMD_display_native_hdr ===
|
|
|
15736
|
|
|
15737 // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html
|
|
|
15738 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15739 void setLocalDimmingAMD( SwapchainKHR swapChain,
|
|
|
15740 Bool32 localDimmingEnable,
|
|
|
15741 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15742
|
|
|
15743 //=== VK_EXT_buffer_device_address ===
|
|
|
15744
|
|
|
15745 // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html
|
|
|
15746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15747 DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo * pInfo,
|
|
|
15748 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15749 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15750 // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html
|
|
|
15751 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15752 DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo & info,
|
|
|
15753 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15755
|
|
|
15756 //=== VK_KHR_present_wait ===
|
|
|
15757
|
|
|
15758 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15759 // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html
|
|
|
15760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15761 VULKAN_HPP_NODISCARD Result waitForPresentKHR( SwapchainKHR swapchain,
|
|
|
15762 uint64_t presentId,
|
|
|
15763 uint64_t timeout,
|
|
|
15764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15765 #else
|
|
|
15766 // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html
|
|
|
15767 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15768 VULKAN_HPP_NODISCARD Result
|
|
|
15769 waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15770 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15771
|
|
|
15772 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
15773 //=== VK_EXT_full_screen_exclusive ===
|
|
|
15774
|
|
|
15775 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15776 // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see
|
|
|
15777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html
|
|
|
15778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15779 VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain,
|
|
|
15780 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15781 # else
|
|
|
15782 // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see
|
|
|
15783 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html
|
|
|
15784 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15785 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15786 acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15787 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15788
|
|
|
15789 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15790 // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see
|
|
|
15791 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html
|
|
|
15792 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15793 VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain,
|
|
|
15794 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15795 # else
|
|
|
15796 // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see
|
|
|
15797 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html
|
|
|
15798 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15799 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
15800 releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15801 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15802
|
|
|
15803 // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see
|
|
|
15804 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html
|
|
|
15805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15806 VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
15807 DeviceGroupPresentModeFlagsKHR * pModes,
|
|
|
15808 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15809 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15810 // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see
|
|
|
15811 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html
|
|
|
15812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15813 VULKAN_HPP_NODISCARD typename ResultValueType<DeviceGroupPresentModeFlagsKHR>::type
|
|
|
15814 getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15815 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15816 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
15817
|
|
|
15818 //=== VK_KHR_buffer_device_address ===
|
|
|
15819
|
|
|
15820 // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html
|
|
|
15821 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15822 DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo * pInfo,
|
|
|
15823 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15824 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15825 // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html
|
|
|
15826 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15827 DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo & info,
|
|
|
15828 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15829 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15830
|
|
|
15831 // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see
|
|
|
15832 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html
|
|
|
15833 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15834 uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo * pInfo,
|
|
|
15835 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15837 // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see
|
|
|
15838 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html
|
|
|
15839 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15840 uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
|
|
|
15841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15842 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15843
|
|
|
15844 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see
|
|
|
15845 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html
|
|
|
15846 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15847 uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
|
|
|
15848 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15850 // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see
|
|
|
15851 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html
|
|
|
15852 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15853 uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info,
|
|
|
15854 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15855 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15856
|
|
|
15857 //=== VK_EXT_host_query_reset ===
|
|
|
15858
|
|
|
15859 // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html
|
|
|
15860 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15861 void resetQueryPoolEXT( QueryPool queryPool,
|
|
|
15862 uint32_t firstQuery,
|
|
|
15863 uint32_t queryCount,
|
|
|
15864 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15865
|
|
|
15866 //=== VK_KHR_deferred_host_operations ===
|
|
|
15867
|
|
|
15868 // wrapper function for command vkCreateDeferredOperationKHR, see
|
|
|
15869 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
|
|
|
15870 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15871 VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const AllocationCallbacks * pAllocator,
|
|
|
15872 DeferredOperationKHR * pDeferredOperation,
|
|
|
15873 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15875 // wrapper function for command vkCreateDeferredOperationKHR, see
|
|
|
15876 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
|
|
|
15877 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15878 VULKAN_HPP_NODISCARD typename ResultValueType<DeferredOperationKHR>::type
|
|
|
15879 createDeferredOperationKHR( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15880 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15881 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
15882 // wrapper function for command vkCreateDeferredOperationKHR, see
|
|
|
15883 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html
|
|
|
15884 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15885 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DeferredOperationKHR, Dispatch>>::type
|
|
|
15886 createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15887 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15888 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
15889 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15890
|
|
|
15891 // wrapper function for command vkDestroyDeferredOperationKHR, see
|
|
|
15892 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
|
|
|
15893 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15894 void destroyDeferredOperationKHR( DeferredOperationKHR operation,
|
|
|
15895 const AllocationCallbacks * pAllocator,
|
|
|
15896 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15898 // wrapper function for command vkDestroyDeferredOperationKHR, see
|
|
|
15899 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
|
|
|
15900 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15901 void destroyDeferredOperationKHR( DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
15902 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15903 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15904 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15905
|
|
|
15906 // wrapper function for command vkDestroyDeferredOperationKHR, see
|
|
|
15907 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
|
|
|
15908 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15909 void destroy( DeferredOperationKHR operation,
|
|
|
15910 const AllocationCallbacks * pAllocator,
|
|
|
15911 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15912 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15913 // wrapper function for command vkDestroyDeferredOperationKHR, see
|
|
|
15914 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html
|
|
|
15915 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15916 void destroy( DeferredOperationKHR operation,
|
|
|
15917 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
15918 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15919 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15920
|
|
|
15921 // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see
|
|
|
15922 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html
|
|
|
15923 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15924 uint32_t getDeferredOperationMaxConcurrencyKHR( DeferredOperationKHR operation,
|
|
|
15925 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15926
|
|
|
15927 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15928 // wrapper function for command vkGetDeferredOperationResultKHR, see
|
|
|
15929 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
|
|
|
15930 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15931 VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation,
|
|
|
15932 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15933 #else
|
|
|
15934 // wrapper function for command vkGetDeferredOperationResultKHR, see
|
|
|
15935 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
|
|
|
15936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15937 VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation,
|
|
|
15938 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15939 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15940
|
|
|
15941 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15942 // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html
|
|
|
15943 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15944 VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation,
|
|
|
15945 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15946 #else
|
|
|
15947 // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html
|
|
|
15948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15949 VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15950 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
15951
|
|
|
15952 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
15953
|
|
|
15954 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
|
|
|
15955 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
|
|
|
15956 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15957 VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const PipelineInfoKHR * pPipelineInfo,
|
|
|
15958 uint32_t * pExecutableCount,
|
|
|
15959 PipelineExecutablePropertiesKHR * pProperties,
|
|
|
15960 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15961 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15962 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
|
|
|
15963 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
|
|
|
15964 template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
|
|
|
15965 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15966 typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, PipelineExecutablePropertiesKHR>::value,
|
|
|
15967 int>::type = 0,
|
|
|
15968 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15969 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
|
|
|
15970 getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15971 // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see
|
|
|
15972 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html
|
|
|
15973 template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
|
|
|
15974 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15975 typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, PipelineExecutablePropertiesKHR>::value,
|
|
|
15976 int>::type = 0,
|
|
|
15977 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15978 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
|
|
|
15979 getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
|
|
|
15980 PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
|
|
|
15981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
15982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
15983
|
|
|
15984 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
|
|
|
15985 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
|
|
|
15986 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15987 VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR * pExecutableInfo,
|
|
|
15988 uint32_t * pStatisticCount,
|
|
|
15989 PipelineExecutableStatisticKHR * pStatistics,
|
|
|
15990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
15991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
15992 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
|
|
|
15993 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
|
|
|
15994 template <
|
|
|
15995 typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
|
|
|
15996 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
15997 typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0,
|
|
|
15998 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
15999 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
|
|
|
16000 getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16001 // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see
|
|
|
16002 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html
|
|
|
16003 template <
|
|
|
16004 typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
|
|
|
16005 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16006 typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0,
|
|
|
16007 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16008 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
|
|
|
16009 getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
|
|
|
16010 PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
|
|
|
16011 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16012 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16013
|
|
|
16014 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
|
|
|
16015 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
|
|
|
16016 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16017 VULKAN_HPP_NODISCARD Result
|
|
|
16018 getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR * pExecutableInfo,
|
|
|
16019 uint32_t * pInternalRepresentationCount,
|
|
|
16020 PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
|
|
|
16021 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16023 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
|
|
|
16024 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
|
|
|
16025 template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<PipelineExecutableInternalRepresentationKHR>,
|
|
|
16026 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16027 typename std::enable_if<
|
|
|
16028 std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, PipelineExecutableInternalRepresentationKHR>::value,
|
|
|
16029 int>::type = 0,
|
|
|
16030 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16031 VULKAN_HPP_NODISCARD
|
|
|
16032 typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
|
|
|
16033 getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
|
|
|
16034 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16035 // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see
|
|
|
16036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html
|
|
|
16037 template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<PipelineExecutableInternalRepresentationKHR>,
|
|
|
16038 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16039 typename std::enable_if<
|
|
|
16040 std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, PipelineExecutableInternalRepresentationKHR>::value,
|
|
|
16041 int>::type = 0,
|
|
|
16042 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16043 VULKAN_HPP_NODISCARD
|
|
|
16044 typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
|
|
|
16045 getPipelineExecutableInternalRepresentationsKHR(
|
|
|
16046 const PipelineExecutableInfoKHR & executableInfo,
|
|
|
16047 PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
|
|
|
16048 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16049 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16050
|
|
|
16051 //=== VK_EXT_host_image_copy ===
|
|
|
16052
|
|
|
16053 // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html
|
|
|
16054 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16055 VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
|
|
|
16056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16057 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16058 // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html
|
|
|
16059 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16060 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16061 copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16062 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16063
|
|
|
16064 // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html
|
|
|
16065 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16066 VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
|
|
|
16067 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16069 // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html
|
|
|
16070 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16071 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16072 copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16073 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16074
|
|
|
16075 // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html
|
|
|
16076 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16077 VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const CopyImageToImageInfo * pCopyImageToImageInfo,
|
|
|
16078 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16079 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16080 // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html
|
|
|
16081 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16082 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16083 copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16084 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16085
|
|
|
16086 // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html
|
|
|
16087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16088 VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t transitionCount,
|
|
|
16089 const HostImageLayoutTransitionInfo * pTransitions,
|
|
|
16090 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16092 // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html
|
|
|
16093 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16094 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16095 transitionImageLayoutEXT( ArrayProxy<const HostImageLayoutTransitionInfo> const & transitions,
|
|
|
16096 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16097 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16098
|
|
|
16099 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
|
|
|
16100 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
|
|
|
16101 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16102 void getImageSubresourceLayout2EXT( Image image,
|
|
|
16103 const ImageSubresource2 * pSubresource,
|
|
|
16104 SubresourceLayout2 * pLayout,
|
|
|
16105 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16107 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
|
|
|
16108 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
|
|
|
16109 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16110 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2EXT(
|
|
|
16111 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16112 // wrapper function for command vkGetImageSubresourceLayout2EXT, see
|
|
|
16113 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html
|
|
|
16114 template <typename X,
|
|
|
16115 typename Y,
|
|
|
16116 typename... Z,
|
|
|
16117 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16118 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16119 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageSubresourceLayout2EXT(
|
|
|
16120 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16121 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16122
|
|
|
16123 //=== VK_KHR_map_memory2 ===
|
|
|
16124
|
|
|
16125 // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html
|
|
|
16126 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16127 VULKAN_HPP_NODISCARD Result mapMemory2KHR( const MemoryMapInfo * pMemoryMapInfo,
|
|
|
16128 void ** ppData,
|
|
|
16129 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16131 // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html
|
|
|
16132 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16133 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const MemoryMapInfo & memoryMapInfo,
|
|
|
16134 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16135 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16136
|
|
|
16137 // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
|
|
|
16138 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16139 VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const MemoryUnmapInfo * pMemoryUnmapInfo,
|
|
|
16140 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16142 // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
|
|
|
16143 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16144 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16145 unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16147
|
|
|
16148 //=== VK_EXT_swapchain_maintenance1 ===
|
|
|
16149
|
|
|
16150 // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
|
|
|
16151 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16152 VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo,
|
|
|
16153 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16155 // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
|
|
|
16156 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16157 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16158 releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16159 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16160
|
|
|
16161 //=== VK_NV_device_generated_commands ===
|
|
|
16162
|
|
|
16163 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
|
|
|
16164 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
|
|
|
16165 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16166 void getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
|
|
|
16167 MemoryRequirements2 * pMemoryRequirements,
|
|
|
16168 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16169 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16170 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
|
|
|
16171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
|
|
|
16172 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16173 VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
|
|
|
16174 const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16175 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see
|
|
|
16176 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html
|
|
|
16177 template <typename X,
|
|
|
16178 typename Y,
|
|
|
16179 typename... Z,
|
|
|
16180 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16181 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16182 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
16183 getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info,
|
|
|
16184 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16185 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16186
|
|
|
16187 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
|
|
|
16188 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
|
|
|
16189 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16190 VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
|
|
|
16191 const AllocationCallbacks * pAllocator,
|
|
|
16192 IndirectCommandsLayoutNV * pIndirectCommandsLayout,
|
|
|
16193 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16195 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
|
|
|
16196 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
|
|
|
16197 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16198 VULKAN_HPP_NODISCARD typename ResultValueType<IndirectCommandsLayoutNV>::type
|
|
|
16199 createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV & createInfo,
|
|
|
16200 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16201 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16202 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
16203 // wrapper function for command vkCreateIndirectCommandsLayoutNV, see
|
|
|
16204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html
|
|
|
16205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16206 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNV, Dispatch>>::type
|
|
|
16207 createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo,
|
|
|
16208 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16209 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16210 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
16211 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16212
|
|
|
16213 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
|
|
|
16214 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
|
|
|
16215 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16216 void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout,
|
|
|
16217 const AllocationCallbacks * pAllocator,
|
|
|
16218 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16219 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16220 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
|
|
|
16221 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
|
|
|
16222 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16223 void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
16224 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16225 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16226 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16227
|
|
|
16228 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
|
|
|
16229 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
|
|
|
16230 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16231 void destroy( IndirectCommandsLayoutNV indirectCommandsLayout,
|
|
|
16232 const AllocationCallbacks * pAllocator,
|
|
|
16233 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16234 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16235 // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see
|
|
|
16236 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html
|
|
|
16237 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16238 void destroy( IndirectCommandsLayoutNV indirectCommandsLayout,
|
|
|
16239 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16240 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16241 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16242
|
|
|
16243 //=== VK_EXT_private_data ===
|
|
|
16244
|
|
|
16245 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
|
|
|
16246 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16247 VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo * pCreateInfo,
|
|
|
16248 const AllocationCallbacks * pAllocator,
|
|
|
16249 PrivateDataSlot * pPrivateDataSlot,
|
|
|
16250 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16252 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
|
|
|
16253 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16254 VULKAN_HPP_NODISCARD typename ResultValueType<PrivateDataSlot>::type
|
|
|
16255 createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo & createInfo,
|
|
|
16256 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16257 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16258 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
16259 // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html
|
|
|
16260 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16261 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<PrivateDataSlot, Dispatch>>::type
|
|
|
16262 createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfo & createInfo,
|
|
|
16263 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16264 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16265 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
16266 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16267
|
|
|
16268 // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html
|
|
|
16269 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16270 void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot,
|
|
|
16271 const AllocationCallbacks * pAllocator,
|
|
|
16272 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16273 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16274 // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html
|
|
|
16275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16276 void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
16277 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16278 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16280
|
|
|
16281 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16282 // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
|
|
|
16283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16284 VULKAN_HPP_NODISCARD Result setPrivateDataEXT( ObjectType objectType,
|
|
|
16285 uint64_t objectHandle,
|
|
|
16286 PrivateDataSlot privateDataSlot,
|
|
|
16287 uint64_t data,
|
|
|
16288 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16289 #else
|
|
|
16290 // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
|
|
|
16291 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16292 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16293 setPrivateDataEXT( ObjectType objectType,
|
|
|
16294 uint64_t objectHandle,
|
|
|
16295 PrivateDataSlot privateDataSlot,
|
|
|
16296 uint64_t data,
|
|
|
16297 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16298 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
16299
|
|
|
16300 // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html
|
|
|
16301 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16302 void getPrivateDataEXT( ObjectType objectType,
|
|
|
16303 uint64_t objectHandle,
|
|
|
16304 PrivateDataSlot privateDataSlot,
|
|
|
16305 uint64_t * pData,
|
|
|
16306 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16308 // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html
|
|
|
16309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16310 VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( ObjectType objectType,
|
|
|
16311 uint64_t objectHandle,
|
|
|
16312 PrivateDataSlot privateDataSlot,
|
|
|
16313 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16315
|
|
|
16316 //=== VK_KHR_video_encode_queue ===
|
|
|
16317
|
|
|
16318 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
|
|
|
16319 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
|
|
|
16320 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16321 VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
|
|
|
16322 VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo,
|
|
|
16323 size_t * pDataSize,
|
|
|
16324 void * pData,
|
|
|
16325 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16326 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16327 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
|
|
|
16328 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
|
|
|
16329 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
16330 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16331 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
16332 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16333 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
|
|
|
16334 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
|
|
|
16335 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16336 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
|
|
|
16337 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
|
|
|
16338 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
16339 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16340 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
16341 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16342 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
|
|
|
16343 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
|
|
|
16344 Uint8_tAllocator & uint8_tAllocator,
|
|
|
16345 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16346 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
|
|
|
16347 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
|
|
|
16348 template <typename X,
|
|
|
16349 typename Y,
|
|
|
16350 typename... Z,
|
|
|
16351 typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
16352 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16353 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
16354 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16355 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
|
|
|
16356 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
|
|
|
16357 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16358 // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see
|
|
|
16359 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html
|
|
|
16360 template <typename X,
|
|
|
16361 typename Y,
|
|
|
16362 typename... Z,
|
|
|
16363 typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
16364 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16365 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
16366 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16367 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
|
|
|
16368 getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
|
|
|
16369 Uint8_tAllocator & uint8_tAllocator,
|
|
|
16370 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16371 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16372
|
|
|
16373 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
16374 //=== VK_NV_cuda_kernel_launch ===
|
|
|
16375
|
|
|
16376 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
|
|
|
16377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16378 VULKAN_HPP_NODISCARD Result createCudaModuleNV( const CudaModuleCreateInfoNV * pCreateInfo,
|
|
|
16379 const AllocationCallbacks * pAllocator,
|
|
|
16380 CudaModuleNV * pModule,
|
|
|
16381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16382 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16383 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
|
|
|
16384 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16385 VULKAN_HPP_NODISCARD typename ResultValueType<CudaModuleNV>::type
|
|
|
16386 createCudaModuleNV( const CudaModuleCreateInfoNV & createInfo,
|
|
|
16387 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16388 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16389 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
16390 // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html
|
|
|
16391 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16392 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CudaModuleNV, Dispatch>>::type
|
|
|
16393 createCudaModuleNVUnique( const CudaModuleCreateInfoNV & createInfo,
|
|
|
16394 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16395 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16396 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
16397 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16398
|
|
|
16399 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
|
|
|
16400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16401 VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( CudaModuleNV module,
|
|
|
16402 size_t * pCacheSize,
|
|
|
16403 void * pCacheData,
|
|
|
16404 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16405 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16406 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
|
|
|
16407 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
16408 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16409 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
16410 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16411 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
|
|
|
16412 getCudaModuleCacheNV( CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16413 // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html
|
|
|
16414 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
16415 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16416 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
16417 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16418 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
|
|
|
16419 getCudaModuleCacheNV( CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16420 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16421
|
|
|
16422 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
|
|
|
16423 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16424 VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const CudaFunctionCreateInfoNV * pCreateInfo,
|
|
|
16425 const AllocationCallbacks * pAllocator,
|
|
|
16426 CudaFunctionNV * pFunction,
|
|
|
16427 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16428 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16429 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
|
|
|
16430 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16431 VULKAN_HPP_NODISCARD typename ResultValueType<CudaFunctionNV>::type
|
|
|
16432 createCudaFunctionNV( const CudaFunctionCreateInfoNV & createInfo,
|
|
|
16433 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16434 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16435 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
16436 // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html
|
|
|
16437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16438 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<CudaFunctionNV, Dispatch>>::type
|
|
|
16439 createCudaFunctionNVUnique( const CudaFunctionCreateInfoNV & createInfo,
|
|
|
16440 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16441 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16442 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
16443 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16444
|
|
|
16445 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
|
|
|
16446 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16447 void destroyCudaModuleNV( CudaModuleNV module,
|
|
|
16448 const AllocationCallbacks * pAllocator,
|
|
|
16449 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16450 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16451 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
|
|
|
16452 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16453 void destroyCudaModuleNV( CudaModuleNV module,
|
|
|
16454 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16456 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16457
|
|
|
16458 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
|
|
|
16459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16460 void destroy( CudaModuleNV module,
|
|
|
16461 const AllocationCallbacks * pAllocator,
|
|
|
16462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16463 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16464 // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html
|
|
|
16465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16466 void destroy( CudaModuleNV module,
|
|
|
16467 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16468 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16469 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16470
|
|
|
16471 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
|
|
|
16472 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16473 void destroyCudaFunctionNV( CudaFunctionNV function,
|
|
|
16474 const AllocationCallbacks * pAllocator,
|
|
|
16475 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16476 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16477 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
|
|
|
16478 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16479 void destroyCudaFunctionNV( CudaFunctionNV function,
|
|
|
16480 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16481 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16482 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16483
|
|
|
16484 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
|
|
|
16485 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16486 void destroy( CudaFunctionNV function,
|
|
|
16487 const AllocationCallbacks * pAllocator,
|
|
|
16488 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16489 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16490 // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html
|
|
|
16491 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16492 void destroy( CudaFunctionNV function,
|
|
|
16493 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16494 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16495 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16496 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
16497
|
|
|
16498 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
16499 //=== VK_EXT_metal_objects ===
|
|
|
16500
|
|
|
16501 // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
|
|
|
16502 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16503 void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT * pMetalObjectsInfo,
|
|
|
16504 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16505 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16506 // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
|
|
|
16507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16508 void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo,
|
|
|
16509 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16510 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16511 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
16512
|
|
|
16513 //=== VK_EXT_descriptor_buffer ===
|
|
|
16514
|
|
|
16515 // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see
|
|
|
16516 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html
|
|
|
16517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16518 void getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout,
|
|
|
16519 DeviceSize * pLayoutSizeInBytes,
|
|
|
16520 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16521 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16522 // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see
|
|
|
16523 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html
|
|
|
16524 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16525 VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout,
|
|
|
16526 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16527 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16528
|
|
|
16529 // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see
|
|
|
16530 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html
|
|
|
16531 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16532 void getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout,
|
|
|
16533 uint32_t binding,
|
|
|
16534 DeviceSize * pOffset,
|
|
|
16535 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16537 // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see
|
|
|
16538 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html
|
|
|
16539 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16540 VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutBindingOffsetEXT(
|
|
|
16541 DescriptorSetLayout layout, uint32_t binding, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16543
|
|
|
16544 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
|
|
|
16545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16546 void getDescriptorEXT( const DescriptorGetInfoEXT * pDescriptorInfo,
|
|
|
16547 size_t dataSize,
|
|
|
16548 void * pDescriptor,
|
|
|
16549 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16551 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
|
|
|
16552 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16553 void getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo,
|
|
|
16554 size_t dataSize,
|
|
|
16555 void * pDescriptor,
|
|
|
16556 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16557 // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html
|
|
|
16558 template <typename DescriptorType,
|
|
|
16559 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16560 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16561 VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo,
|
|
|
16562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16563 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16564
|
|
|
16565 // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see
|
|
|
16566 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html
|
|
|
16567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16568 VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT(
|
|
|
16569 const BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16570 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16571 // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see
|
|
|
16572 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html
|
|
|
16573 template <typename DataType,
|
|
|
16574 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16575 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16576 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
16577 getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info,
|
|
|
16578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16580
|
|
|
16581 // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see
|
|
|
16582 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html
|
|
|
16583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16584 VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT * pInfo,
|
|
|
16585 void * pData,
|
|
|
16586 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16588 // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see
|
|
|
16589 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html
|
|
|
16590 template <typename DataType,
|
|
|
16591 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16592 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16593 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
16594 getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info,
|
|
|
16595 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16596 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16597
|
|
|
16598 // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see
|
|
|
16599 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html
|
|
|
16600 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16601 VULKAN_HPP_NODISCARD Result
|
|
|
16602 getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT * pInfo,
|
|
|
16603 void * pData,
|
|
|
16604 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16606 // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see
|
|
|
16607 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html
|
|
|
16608 template <typename DataType,
|
|
|
16609 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16610 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16611 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
16612 getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info,
|
|
|
16613 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16615
|
|
|
16616 // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see
|
|
|
16617 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html
|
|
|
16618 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16619 VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT(
|
|
|
16620 const SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16621 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16622 // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see
|
|
|
16623 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html
|
|
|
16624 template <typename DataType,
|
|
|
16625 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16626 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16627 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
16628 getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info,
|
|
|
16629 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16630 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16631
|
|
|
16632 // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see
|
|
|
16633 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html
|
|
|
16634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16635 VULKAN_HPP_NODISCARD Result
|
|
|
16636 getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
|
|
|
16637 void * pData,
|
|
|
16638 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16639 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16640 // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see
|
|
|
16641 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html
|
|
|
16642 template <typename DataType,
|
|
|
16643 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16644 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16645 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
16646 getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info,
|
|
|
16647 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16648 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16649
|
|
|
16650 //=== VK_EXT_device_fault ===
|
|
|
16651
|
|
|
16652 // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html
|
|
|
16653 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16654 VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts,
|
|
|
16655 DeviceFaultInfoEXT * pFaultInfo,
|
|
|
16656 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16657
|
|
|
16658 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
16659 //=== VK_FUCHSIA_external_memory ===
|
|
|
16660
|
|
|
16661 // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see
|
|
|
16662 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html
|
|
|
16663 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16664 VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
|
|
|
16665 zx_handle_t * pZirconHandle,
|
|
|
16666 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16667 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16668 // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see
|
|
|
16669 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html
|
|
|
16670 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16671 VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
|
|
|
16672 getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
|
|
|
16673 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16674 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16675
|
|
|
16676 // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see
|
|
|
16677 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html
|
|
|
16678 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16679 VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType,
|
|
|
16680 zx_handle_t zirconHandle,
|
|
|
16681 MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
|
|
|
16682 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16683 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16684 // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see
|
|
|
16685 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html
|
|
|
16686 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16687 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryZirconHandlePropertiesFUCHSIA>::type getMemoryZirconHandlePropertiesFUCHSIA(
|
|
|
16688 ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16689 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16690 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
16691
|
|
|
16692 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
16693 //=== VK_FUCHSIA_external_semaphore ===
|
|
|
16694
|
|
|
16695 // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see
|
|
|
16696 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html
|
|
|
16697 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16698 VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
|
|
|
16699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16700 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16701 // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see
|
|
|
16702 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html
|
|
|
16703 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16704 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16705 importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
|
|
|
16706 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16707 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16708
|
|
|
16709 // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see
|
|
|
16710 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html
|
|
|
16711 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16712 VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
|
|
|
16713 zx_handle_t * pZirconHandle,
|
|
|
16714 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16715 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16716 // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see
|
|
|
16717 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html
|
|
|
16718 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16719 VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
|
|
|
16720 getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
|
|
|
16721 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16722 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16723 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
16724
|
|
|
16725 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
16726 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
16727
|
|
|
16728 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
|
|
|
16729 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
|
|
|
16730 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16731 VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
|
|
|
16732 const AllocationCallbacks * pAllocator,
|
|
|
16733 BufferCollectionFUCHSIA * pCollection,
|
|
|
16734 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16735 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16736 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
|
|
|
16737 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
|
|
|
16738 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16739 VULKAN_HPP_NODISCARD typename ResultValueType<BufferCollectionFUCHSIA>::type
|
|
|
16740 createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA & createInfo,
|
|
|
16741 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16742 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16743 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
16744 // wrapper function for command vkCreateBufferCollectionFUCHSIA, see
|
|
|
16745 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html
|
|
|
16746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16747 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<BufferCollectionFUCHSIA, Dispatch>>::type
|
|
|
16748 createBufferCollectionFUCHSIAUnique( const BufferCollectionCreateInfoFUCHSIA & createInfo,
|
|
|
16749 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16750 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16751 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
16752 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16753
|
|
|
16754 // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see
|
|
|
16755 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html
|
|
|
16756 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16757 VULKAN_HPP_NODISCARD Result
|
|
|
16758 setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
|
|
|
16759 const ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
|
|
|
16760 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16761 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16762 // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see
|
|
|
16763 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html
|
|
|
16764 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16765 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16766 setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
|
|
|
16767 const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
|
|
|
16768 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16769 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16770
|
|
|
16771 // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see
|
|
|
16772 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html
|
|
|
16773 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16774 VULKAN_HPP_NODISCARD Result
|
|
|
16775 setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
|
|
|
16776 const BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
|
|
|
16777 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16778 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16779 // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see
|
|
|
16780 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html
|
|
|
16781 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16782 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
16783 setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection,
|
|
|
16784 const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
|
|
|
16785 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16786 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16787
|
|
|
16788 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
|
|
|
16789 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
|
|
|
16790 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16791 void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection,
|
|
|
16792 const AllocationCallbacks * pAllocator,
|
|
|
16793 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16794 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16795 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
|
|
|
16796 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
|
|
|
16797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16798 void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection,
|
|
|
16799 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16800 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16801 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16802
|
|
|
16803 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
|
|
|
16804 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
|
|
|
16805 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16806 void destroy( BufferCollectionFUCHSIA collection,
|
|
|
16807 const AllocationCallbacks * pAllocator,
|
|
|
16808 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16809 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16810 // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see
|
|
|
16811 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html
|
|
|
16812 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16813 void destroy( BufferCollectionFUCHSIA collection,
|
|
|
16814 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16815 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16816 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16817
|
|
|
16818 // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see
|
|
|
16819 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html
|
|
|
16820 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16821 VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection,
|
|
|
16822 BufferCollectionPropertiesFUCHSIA * pProperties,
|
|
|
16823 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16824 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16825 // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see
|
|
|
16826 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html
|
|
|
16827 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16828 VULKAN_HPP_NODISCARD typename ResultValueType<BufferCollectionPropertiesFUCHSIA>::type
|
|
|
16829 getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16830 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16831 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
16832
|
|
|
16833 //=== VK_HUAWEI_subpass_shading ===
|
|
|
16834
|
|
|
16835 // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see
|
|
|
16836 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html
|
|
|
16837 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16838 VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(
|
|
|
16839 RenderPass renderpass, Extent2D * pMaxWorkgroupSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16840 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16841 // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see
|
|
|
16842 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html
|
|
|
16843 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16844 VULKAN_HPP_NODISCARD typename ResultValueType<Extent2D>::type
|
|
|
16845 getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16846 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16847
|
|
|
16848 //=== VK_NV_external_memory_rdma ===
|
|
|
16849
|
|
|
16850 // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html
|
|
|
16851 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16852 VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
|
|
|
16853 RemoteAddressNV * pAddress,
|
|
|
16854 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16855 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16856 // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html
|
|
|
16857 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16858 VULKAN_HPP_NODISCARD typename ResultValueType<RemoteAddressNV>::type
|
|
|
16859 getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
|
|
|
16860 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16861 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16862
|
|
|
16863 //=== VK_EXT_pipeline_properties ===
|
|
|
16864
|
|
|
16865 // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html
|
|
|
16866 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16867 VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const PipelineInfoEXT * pPipelineInfo,
|
|
|
16868 BaseOutStructure * pPipelineProperties,
|
|
|
16869 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16871 // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html
|
|
|
16872 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16873 VULKAN_HPP_NODISCARD typename ResultValueType<BaseOutStructure>::type
|
|
|
16874 getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16875 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16876
|
|
|
16877 //=== VK_EXT_opacity_micromap ===
|
|
|
16878
|
|
|
16879 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
|
|
|
16880 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16881 VULKAN_HPP_NODISCARD Result createMicromapEXT( const MicromapCreateInfoEXT * pCreateInfo,
|
|
|
16882 const AllocationCallbacks * pAllocator,
|
|
|
16883 MicromapEXT * pMicromap,
|
|
|
16884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16885 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16886 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
|
|
|
16887 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16888 VULKAN_HPP_NODISCARD typename ResultValueType<MicromapEXT>::type
|
|
|
16889 createMicromapEXT( const MicromapCreateInfoEXT & createInfo,
|
|
|
16890 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16891 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16892 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
16893 // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html
|
|
|
16894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16895 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<MicromapEXT, Dispatch>>::type
|
|
|
16896 createMicromapEXTUnique( const MicromapCreateInfoEXT & createInfo,
|
|
|
16897 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16898 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16899 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
16900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16901
|
|
|
16902 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
|
|
|
16903 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16904 void destroyMicromapEXT( MicromapEXT micromap,
|
|
|
16905 const AllocationCallbacks * pAllocator,
|
|
|
16906 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16907 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16908 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
|
|
|
16909 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16910 void destroyMicromapEXT( MicromapEXT micromap VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
16911 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16912 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16913 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16914
|
|
|
16915 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
|
|
|
16916 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16917 void destroy( MicromapEXT micromap,
|
|
|
16918 const AllocationCallbacks * pAllocator,
|
|
|
16919 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16920 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16921 // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html
|
|
|
16922 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16923 void destroy( MicromapEXT micromap,
|
|
|
16924 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
16925 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16926 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16927
|
|
|
16928 // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html
|
|
|
16929 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16930 VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation,
|
|
|
16931 uint32_t infoCount,
|
|
|
16932 const MicromapBuildInfoEXT * pInfos,
|
|
|
16933 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16935 // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html
|
|
|
16936 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16937 VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation,
|
|
|
16938 ArrayProxy<const MicromapBuildInfoEXT> const & infos,
|
|
|
16939 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16941
|
|
|
16942 // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html
|
|
|
16943 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16944 VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation,
|
|
|
16945 const CopyMicromapInfoEXT * pInfo,
|
|
|
16946 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16948 // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html
|
|
|
16949 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16950 VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation,
|
|
|
16951 const CopyMicromapInfoEXT & info,
|
|
|
16952 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16953 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16954
|
|
|
16955 // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html
|
|
|
16956 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16957 VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation,
|
|
|
16958 const CopyMicromapToMemoryInfoEXT * pInfo,
|
|
|
16959 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16960 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16961 // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html
|
|
|
16962 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16963 VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation,
|
|
|
16964 const CopyMicromapToMemoryInfoEXT & info,
|
|
|
16965 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16966 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16967
|
|
|
16968 // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html
|
|
|
16969 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16970 VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation,
|
|
|
16971 const CopyMemoryToMicromapInfoEXT * pInfo,
|
|
|
16972 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16974 // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html
|
|
|
16975 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16976 VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation,
|
|
|
16977 const CopyMemoryToMicromapInfoEXT & info,
|
|
|
16978 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
16979 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
16980
|
|
|
16981 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
|
|
|
16982 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
|
|
|
16983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16984 VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t micromapCount,
|
|
|
16985 const MicromapEXT * pMicromaps,
|
|
|
16986 QueryType queryType,
|
|
|
16987 size_t dataSize,
|
|
|
16988 void * pData,
|
|
|
16989 size_t stride,
|
|
|
16990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
16991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
16992 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
|
|
|
16993 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
|
|
|
16994 template <typename DataType,
|
|
|
16995 typename DataTypeAllocator = std::allocator<DataType>,
|
|
|
16996 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
16997 typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType>::value, int>::type = 0,
|
|
|
16998 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
16999 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
|
|
|
17000 writeMicromapsPropertiesEXT( ArrayProxy<const MicromapEXT> const & micromaps,
|
|
|
17001 QueryType queryType,
|
|
|
17002 size_t dataSize,
|
|
|
17003 size_t stride,
|
|
|
17004 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17005 // wrapper function for command vkWriteMicromapsPropertiesEXT, see
|
|
|
17006 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html
|
|
|
17007 template <typename DataType,
|
|
|
17008 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17009 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17010 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeMicromapsPropertyEXT(
|
|
|
17011 ArrayProxy<const MicromapEXT> const & micromaps, QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17012 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17013
|
|
|
17014 // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see
|
|
|
17015 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html
|
|
|
17016 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17017 void getMicromapCompatibilityEXT( const MicromapVersionInfoEXT * pVersionInfo,
|
|
|
17018 AccelerationStructureCompatibilityKHR * pCompatibility,
|
|
|
17019 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17020 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17021 // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see
|
|
|
17022 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html
|
|
|
17023 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17024 VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT(
|
|
|
17025 const MicromapVersionInfoEXT & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17027
|
|
|
17028 // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html
|
|
|
17029 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17030 void getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType,
|
|
|
17031 const MicromapBuildInfoEXT * pBuildInfo,
|
|
|
17032 MicromapBuildSizesInfoEXT * pSizeInfo,
|
|
|
17033 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17035 // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html
|
|
|
17036 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17037 VULKAN_HPP_NODISCARD MicromapBuildSizesInfoEXT
|
|
|
17038 getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType,
|
|
|
17039 const MicromapBuildInfoEXT & buildInfo,
|
|
|
17040 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17041 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17042
|
|
|
17043 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
17044
|
|
|
17045 // wrapper function for command vkSetDeviceMemoryPriorityEXT, see
|
|
|
17046 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html
|
|
|
17047 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17048 void setMemoryPriorityEXT( DeviceMemory memory, float priority, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17049
|
|
|
17050 //=== VK_KHR_maintenance4 ===
|
|
|
17051
|
|
|
17052 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
|
|
|
17053 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
|
|
|
17054 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17055 void getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements * pInfo,
|
|
|
17056 MemoryRequirements2 * pMemoryRequirements,
|
|
|
17057 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17059 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
|
|
|
17060 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
|
|
|
17061 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17062 VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirementsKHR(
|
|
|
17063 const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17064 // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see
|
|
|
17065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html
|
|
|
17066 template <typename X,
|
|
|
17067 typename Y,
|
|
|
17068 typename... Z,
|
|
|
17069 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17070 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17071 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
17072 getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info,
|
|
|
17073 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17074 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17075
|
|
|
17076 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
|
|
|
17077 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
|
|
|
17078 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17079 void getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo,
|
|
|
17080 MemoryRequirements2 * pMemoryRequirements,
|
|
|
17081 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17083 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
|
|
|
17084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
|
|
|
17085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17086 VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirementsKHR(
|
|
|
17087 const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17088 // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see
|
|
|
17089 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html
|
|
|
17090 template <typename X,
|
|
|
17091 typename Y,
|
|
|
17092 typename... Z,
|
|
|
17093 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17094 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17095 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
17096 getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info,
|
|
|
17097 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17099
|
|
|
17100 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
|
|
|
17101 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
|
|
|
17102 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17103 void getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo,
|
|
|
17104 uint32_t * pSparseMemoryRequirementCount,
|
|
|
17105 SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
|
|
|
17106 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17108 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
|
|
|
17109 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
|
|
|
17110 template <
|
|
|
17111 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
17112 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17113 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
17114 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17115 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
17116 getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17117 // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see
|
|
|
17118 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html
|
|
|
17119 template <
|
|
|
17120 typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
|
|
|
17121 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17122 typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0,
|
|
|
17123 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17124 VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
|
|
|
17125 getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info,
|
|
|
17126 SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
|
|
|
17127 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17128 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17129
|
|
|
17130 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
17131
|
|
|
17132 // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see
|
|
|
17133 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html
|
|
|
17134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17135 void getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE * pBindingReference,
|
|
|
17136 DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping,
|
|
|
17137 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17138 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17139 // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see
|
|
|
17140 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html
|
|
|
17141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17142 VULKAN_HPP_NODISCARD DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE(
|
|
|
17143 const DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17144 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17145
|
|
|
17146 // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see
|
|
|
17147 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html
|
|
|
17148 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17149 void getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet,
|
|
|
17150 void ** ppData,
|
|
|
17151 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17152 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17153 // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see
|
|
|
17154 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html
|
|
|
17155 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17156 VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet,
|
|
|
17157 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17159
|
|
|
17160 //=== VK_NV_device_generated_commands_compute ===
|
|
|
17161
|
|
|
17162 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
|
|
|
17163 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
|
|
|
17164 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17165 void getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo * pCreateInfo,
|
|
|
17166 MemoryRequirements2 * pMemoryRequirements,
|
|
|
17167 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17169 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
|
|
|
17170 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
|
|
|
17171 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17172 VULKAN_HPP_NODISCARD MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV(
|
|
|
17173 const ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17174 // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see
|
|
|
17175 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html
|
|
|
17176 template <typename X,
|
|
|
17177 typename Y,
|
|
|
17178 typename... Z,
|
|
|
17179 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17180 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17181 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
17182 getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo,
|
|
|
17183 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17185
|
|
|
17186 // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see
|
|
|
17187 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html
|
|
|
17188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17189 DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV * pInfo,
|
|
|
17190 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17191 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17192 // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see
|
|
|
17193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html
|
|
|
17194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17195 DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info,
|
|
|
17196 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17197 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17198
|
|
|
17199 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
17200 //=== VK_OHOS_external_memory ===
|
|
|
17201
|
|
|
17202 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
|
|
|
17203 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
|
|
|
17204 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17205 VULKAN_HPP_NODISCARD Result getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer,
|
|
|
17206 NativeBufferPropertiesOHOS * pProperties,
|
|
|
17207 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17208 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17209 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
|
|
|
17210 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
|
|
|
17211 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17212 VULKAN_HPP_NODISCARD typename ResultValueType<NativeBufferPropertiesOHOS>::type
|
|
|
17213 getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17214 // wrapper function for command vkGetNativeBufferPropertiesOHOS, see
|
|
|
17215 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html
|
|
|
17216 template <typename X,
|
|
|
17217 typename Y,
|
|
|
17218 typename... Z,
|
|
|
17219 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17220 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17221 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
17222 getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17223 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17224
|
|
|
17225 // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html
|
|
|
17226 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17227 VULKAN_HPP_NODISCARD Result getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS * pInfo,
|
|
|
17228 struct OH_NativeBuffer ** pBuffer,
|
|
|
17229 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17230 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17231 // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html
|
|
|
17232 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17233 VULKAN_HPP_NODISCARD typename ResultValueType<struct OH_NativeBuffer *>::type
|
|
|
17234 getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17235 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17236 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
17237
|
|
|
17238 //=== VK_ARM_tensors ===
|
|
|
17239
|
|
|
17240 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
|
|
|
17241 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17242 VULKAN_HPP_NODISCARD Result createTensorARM( const TensorCreateInfoARM * pCreateInfo,
|
|
|
17243 const AllocationCallbacks * pAllocator,
|
|
|
17244 TensorARM * pTensor,
|
|
|
17245 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17247 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
|
|
|
17248 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17249 VULKAN_HPP_NODISCARD typename ResultValueType<TensorARM>::type
|
|
|
17250 createTensorARM( const TensorCreateInfoARM & createInfo,
|
|
|
17251 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17252 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17253 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
17254 // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html
|
|
|
17255 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17256 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<TensorARM, Dispatch>>::type
|
|
|
17257 createTensorARMUnique( const TensorCreateInfoARM & createInfo,
|
|
|
17258 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17259 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17260 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
17261 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17262
|
|
|
17263 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
|
|
|
17264 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17265 void destroyTensorARM( TensorARM tensor,
|
|
|
17266 const AllocationCallbacks * pAllocator,
|
|
|
17267 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17269 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
|
|
|
17270 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17271 void destroyTensorARM( TensorARM tensor VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
17272 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17273 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17274 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17275
|
|
|
17276 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
|
|
|
17277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17278 void destroy( TensorARM tensor,
|
|
|
17279 const AllocationCallbacks * pAllocator,
|
|
|
17280 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17282 // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html
|
|
|
17283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17284 void destroy( TensorARM tensor,
|
|
|
17285 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17286 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17288
|
|
|
17289 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
|
|
|
17290 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17291 VULKAN_HPP_NODISCARD Result createTensorViewARM( const TensorViewCreateInfoARM * pCreateInfo,
|
|
|
17292 const AllocationCallbacks * pAllocator,
|
|
|
17293 TensorViewARM * pView,
|
|
|
17294 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17296 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
|
|
|
17297 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17298 VULKAN_HPP_NODISCARD typename ResultValueType<TensorViewARM>::type
|
|
|
17299 createTensorViewARM( const TensorViewCreateInfoARM & createInfo,
|
|
|
17300 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17301 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17302 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
17303 // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html
|
|
|
17304 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17305 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<TensorViewARM, Dispatch>>::type
|
|
|
17306 createTensorViewARMUnique( const TensorViewCreateInfoARM & createInfo,
|
|
|
17307 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17308 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17309 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
17310 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17311
|
|
|
17312 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
|
|
|
17313 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17314 void destroyTensorViewARM( TensorViewARM tensorView,
|
|
|
17315 const AllocationCallbacks * pAllocator,
|
|
|
17316 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17317 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17318 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
|
|
|
17319 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17320 void destroyTensorViewARM( TensorViewARM tensorView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
17321 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17322 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17324
|
|
|
17325 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
|
|
|
17326 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17327 void destroy( TensorViewARM tensorView,
|
|
|
17328 const AllocationCallbacks * pAllocator,
|
|
|
17329 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17331 // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html
|
|
|
17332 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17333 void destroy( TensorViewARM tensorView,
|
|
|
17334 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17335 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17336 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17337
|
|
|
17338 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
|
|
|
17339 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
|
|
|
17340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17341 void getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM * pInfo,
|
|
|
17342 MemoryRequirements2 * pMemoryRequirements,
|
|
|
17343 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17344 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17345 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
|
|
|
17346 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
|
|
|
17347 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17348 VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM(
|
|
|
17349 const TensorMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17350 // wrapper function for command vkGetTensorMemoryRequirementsARM, see
|
|
|
17351 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html
|
|
|
17352 template <typename X,
|
|
|
17353 typename Y,
|
|
|
17354 typename... Z,
|
|
|
17355 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17356 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17357 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
17358 getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info,
|
|
|
17359 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17360 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17361
|
|
|
17362 // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html
|
|
|
17363 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17364 VULKAN_HPP_NODISCARD Result bindTensorMemoryARM( uint32_t bindInfoCount,
|
|
|
17365 const BindTensorMemoryInfoARM * pBindInfos,
|
|
|
17366 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17367 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17368 // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html
|
|
|
17369 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17370 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
17371 bindTensorMemoryARM( ArrayProxy<const BindTensorMemoryInfoARM> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17373
|
|
|
17374 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
|
|
|
17375 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
|
|
|
17376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17377 void getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM * pInfo,
|
|
|
17378 MemoryRequirements2 * pMemoryRequirements,
|
|
|
17379 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17381 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
|
|
|
17382 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
|
|
|
17383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17384 VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM(
|
|
|
17385 const DeviceTensorMemoryRequirementsARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17386 // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see
|
|
|
17387 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html
|
|
|
17388 template <typename X,
|
|
|
17389 typename Y,
|
|
|
17390 typename... Z,
|
|
|
17391 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17392 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17393 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
17394 getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info,
|
|
|
17395 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17396 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17397
|
|
|
17398 // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see
|
|
|
17399 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html
|
|
|
17400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17401 VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDescriptorDataARM(
|
|
|
17402 const TensorCaptureDescriptorDataInfoARM * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17404 // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see
|
|
|
17405 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html
|
|
|
17406 template <typename DataType,
|
|
|
17407 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17408 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17409 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
17410 getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info,
|
|
|
17411 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17412 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17413
|
|
|
17414 // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see
|
|
|
17415 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html
|
|
|
17416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17417 VULKAN_HPP_NODISCARD Result
|
|
|
17418 getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM * pInfo,
|
|
|
17419 void * pData,
|
|
|
17420 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17422 // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see
|
|
|
17423 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html
|
|
|
17424 template <typename DataType,
|
|
|
17425 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17426 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17427 VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
|
|
|
17428 getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info,
|
|
|
17429 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17430 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17431
|
|
|
17432 //=== VK_EXT_shader_module_identifier ===
|
|
|
17433
|
|
|
17434 // wrapper function for command vkGetShaderModuleIdentifierEXT, see
|
|
|
17435 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html
|
|
|
17436 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17437 void getShaderModuleIdentifierEXT( ShaderModule shaderModule,
|
|
|
17438 ShaderModuleIdentifierEXT * pIdentifier,
|
|
|
17439 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17441 // wrapper function for command vkGetShaderModuleIdentifierEXT, see
|
|
|
17442 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html
|
|
|
17443 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17444 VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT
|
|
|
17445 getShaderModuleIdentifierEXT( ShaderModule shaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17446 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17447
|
|
|
17448 // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see
|
|
|
17449 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html
|
|
|
17450 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17451 void getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo * pCreateInfo,
|
|
|
17452 ShaderModuleIdentifierEXT * pIdentifier,
|
|
|
17453 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17455 // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see
|
|
|
17456 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html
|
|
|
17457 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17458 VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT(
|
|
|
17459 const ShaderModuleCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17460 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17461
|
|
|
17462 //=== VK_NV_optical_flow ===
|
|
|
17463
|
|
|
17464 // wrapper function for command vkCreateOpticalFlowSessionNV, see
|
|
|
17465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
|
|
|
17466 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17467 VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV * pCreateInfo,
|
|
|
17468 const AllocationCallbacks * pAllocator,
|
|
|
17469 OpticalFlowSessionNV * pSession,
|
|
|
17470 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17472 // wrapper function for command vkCreateOpticalFlowSessionNV, see
|
|
|
17473 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
|
|
|
17474 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17475 VULKAN_HPP_NODISCARD typename ResultValueType<OpticalFlowSessionNV>::type
|
|
|
17476 createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV & createInfo,
|
|
|
17477 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17479 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
17480 // wrapper function for command vkCreateOpticalFlowSessionNV, see
|
|
|
17481 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html
|
|
|
17482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17483 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<OpticalFlowSessionNV, Dispatch>>::type
|
|
|
17484 createOpticalFlowSessionNVUnique( const OpticalFlowSessionCreateInfoNV & createInfo,
|
|
|
17485 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17486 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17487 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
17488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17489
|
|
|
17490 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
|
|
|
17491 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
|
|
|
17492 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17493 void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session,
|
|
|
17494 const AllocationCallbacks * pAllocator,
|
|
|
17495 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17497 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
|
|
|
17498 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
|
|
|
17499 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17500 void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session,
|
|
|
17501 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17502 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17503 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17504
|
|
|
17505 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
|
|
|
17506 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
|
|
|
17507 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17508 void destroy( OpticalFlowSessionNV session,
|
|
|
17509 const AllocationCallbacks * pAllocator,
|
|
|
17510 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17511 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17512 // wrapper function for command vkDestroyOpticalFlowSessionNV, see
|
|
|
17513 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html
|
|
|
17514 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17515 void destroy( OpticalFlowSessionNV session,
|
|
|
17516 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17517 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17519
|
|
|
17520 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17521 // wrapper function for command vkBindOpticalFlowSessionImageNV, see
|
|
|
17522 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html
|
|
|
17523 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17524 VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session,
|
|
|
17525 OpticalFlowSessionBindingPointNV bindingPoint,
|
|
|
17526 ImageView view,
|
|
|
17527 ImageLayout layout,
|
|
|
17528 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17529 #else
|
|
|
17530 // wrapper function for command vkBindOpticalFlowSessionImageNV, see
|
|
|
17531 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html
|
|
|
17532 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17533 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
17534 bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session,
|
|
|
17535 OpticalFlowSessionBindingPointNV bindingPoint,
|
|
|
17536 ImageView view,
|
|
|
17537 ImageLayout layout,
|
|
|
17538 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17539 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
17540
|
|
|
17541 //=== VK_KHR_maintenance5 ===
|
|
|
17542
|
|
|
17543 // wrapper function for command vkGetRenderingAreaGranularityKHR, see
|
|
|
17544 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html
|
|
|
17545 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17546 void getRenderingAreaGranularityKHR( const RenderingAreaInfo * pRenderingAreaInfo,
|
|
|
17547 Extent2D * pGranularity,
|
|
|
17548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17550 // wrapper function for command vkGetRenderingAreaGranularityKHR, see
|
|
|
17551 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html
|
|
|
17552 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17553 VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo,
|
|
|
17554 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17555 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17556
|
|
|
17557 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
|
|
|
17558 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
|
|
|
17559 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17560 void getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo * pInfo,
|
|
|
17561 SubresourceLayout2 * pLayout,
|
|
|
17562 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17564 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
|
|
|
17565 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
|
|
|
17566 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17567 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayoutKHR(
|
|
|
17568 const DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17569 // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see
|
|
|
17570 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html
|
|
|
17571 template <typename X,
|
|
|
17572 typename Y,
|
|
|
17573 typename... Z,
|
|
|
17574 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17575 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17576 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
17577 getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info,
|
|
|
17578 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17580
|
|
|
17581 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
|
|
|
17582 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
|
|
|
17583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17584 void getImageSubresourceLayout2KHR( Image image,
|
|
|
17585 const ImageSubresource2 * pSubresource,
|
|
|
17586 SubresourceLayout2 * pLayout,
|
|
|
17587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17589 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
|
|
|
17590 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
|
|
|
17591 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17592 VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2KHR(
|
|
|
17593 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17594 // wrapper function for command vkGetImageSubresourceLayout2KHR, see
|
|
|
17595 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html
|
|
|
17596 template <typename X,
|
|
|
17597 typename Y,
|
|
|
17598 typename... Z,
|
|
|
17599 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17600 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17601 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageSubresourceLayout2KHR(
|
|
|
17602 Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17603 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17604
|
|
|
17605 //=== VK_AMD_anti_lag ===
|
|
|
17606
|
|
|
17607 // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html
|
|
|
17608 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17609 void antiLagUpdateAMD( const AntiLagDataAMD * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17610 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17611 // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html
|
|
|
17612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17613 void antiLagUpdateAMD( const AntiLagDataAMD & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17615
|
|
|
17616 //=== VK_KHR_present_wait2 ===
|
|
|
17617
|
|
|
17618 // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html
|
|
|
17619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17620 VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain,
|
|
|
17621 const PresentWait2InfoKHR * pPresentWait2Info,
|
|
|
17622 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17624 // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html
|
|
|
17625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17626 VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain,
|
|
|
17627 const PresentWait2InfoKHR & presentWait2Info,
|
|
|
17628 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17629 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17630
|
|
|
17631 //=== VK_EXT_shader_object ===
|
|
|
17632
|
|
|
17633 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
|
|
|
17634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17635 VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount,
|
|
|
17636 const ShaderCreateInfoEXT * pCreateInfos,
|
|
|
17637 const AllocationCallbacks * pAllocator,
|
|
|
17638 ShaderEXT * pShaders,
|
|
|
17639 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17641 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
|
|
|
17642 template <typename ShaderEXTAllocator = std::allocator<ShaderEXT>,
|
|
|
17643 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17644 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, ShaderEXT>::value, int>::type = 0,
|
|
|
17645 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17646 VULKAN_HPP_NODISCARD ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>>
|
|
|
17647 createShadersEXT( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
|
|
|
17648 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17649 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17650 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
|
|
|
17651 template <typename ShaderEXTAllocator = std::allocator<ShaderEXT>,
|
|
|
17652 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17653 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, ShaderEXT>::value, int>::type = 0,
|
|
|
17654 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17655 VULKAN_HPP_NODISCARD ResultValue<std::vector<ShaderEXT, ShaderEXTAllocator>>
|
|
|
17656 createShadersEXT( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
|
|
|
17657 Optional<const AllocationCallbacks> allocator,
|
|
|
17658 ShaderEXTAllocator & shaderEXTAllocator,
|
|
|
17659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17660 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
|
|
|
17661 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17662 VULKAN_HPP_NODISCARD ResultValue<ShaderEXT> createShaderEXT( const ShaderCreateInfoEXT & createInfo,
|
|
|
17663 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17664 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17665 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
17666 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
|
|
|
17667 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17668 typename ShaderEXTAllocator = std::allocator<UniqueHandle<ShaderEXT, Dispatch>>,
|
|
|
17669 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<ShaderEXT, Dispatch>>::value, int>::type = 0,
|
|
|
17670 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17671 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>>
|
|
|
17672 createShadersEXTUnique( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
|
|
|
17673 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17674 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17675 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
|
|
|
17676 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17677 typename ShaderEXTAllocator = std::allocator<UniqueHandle<ShaderEXT, Dispatch>>,
|
|
|
17678 typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<ShaderEXT, Dispatch>>::value, int>::type = 0,
|
|
|
17679 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17680 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<ShaderEXT, Dispatch>, ShaderEXTAllocator>>
|
|
|
17681 createShadersEXTUnique( ArrayProxy<const ShaderCreateInfoEXT> const & createInfos,
|
|
|
17682 Optional<const AllocationCallbacks> allocator,
|
|
|
17683 ShaderEXTAllocator & shaderEXTAllocator,
|
|
|
17684 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17685 // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html
|
|
|
17686 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17687 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<ShaderEXT, Dispatch>>
|
|
|
17688 createShaderEXTUnique( const ShaderCreateInfoEXT & createInfo,
|
|
|
17689 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17690 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17691 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
17692 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17693
|
|
|
17694 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
|
|
|
17695 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17696 void destroyShaderEXT( ShaderEXT shader,
|
|
|
17697 const AllocationCallbacks * pAllocator,
|
|
|
17698 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17699 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17700 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
|
|
|
17701 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17702 void destroyShaderEXT( ShaderEXT shader VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
17703 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17704 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17705 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17706
|
|
|
17707 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
|
|
|
17708 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17709 void destroy( ShaderEXT shader,
|
|
|
17710 const AllocationCallbacks * pAllocator,
|
|
|
17711 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17713 // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html
|
|
|
17714 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17715 void destroy( ShaderEXT shader,
|
|
|
17716 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17717 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17719
|
|
|
17720 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
|
|
|
17721 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17722 VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( ShaderEXT shader,
|
|
|
17723 size_t * pDataSize,
|
|
|
17724 void * pData,
|
|
|
17725 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17727 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
|
|
|
17728 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
17729 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17730 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
17731 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17732 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
|
|
|
17733 getShaderBinaryDataEXT( ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17734 // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html
|
|
|
17735 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
17736 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17737 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
17738 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17739 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
|
|
|
17740 getShaderBinaryDataEXT( ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17741 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17742
|
|
|
17743 //=== VK_KHR_pipeline_binary ===
|
|
|
17744
|
|
|
17745 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
|
|
|
17746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17747 VULKAN_HPP_NODISCARD Result createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR * pCreateInfo,
|
|
|
17748 const AllocationCallbacks * pAllocator,
|
|
|
17749 PipelineBinaryHandlesInfoKHR * pBinaries,
|
|
|
17750 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17752 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
|
|
|
17753 template <typename PipelineBinaryKHRAllocator = std::allocator<PipelineBinaryKHR>,
|
|
|
17754 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17755 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, PipelineBinaryKHR>::value, int>::type = 0,
|
|
|
17756 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17757 VULKAN_HPP_NODISCARD ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
|
|
|
17758 createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo,
|
|
|
17759 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17760 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17761 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
|
|
|
17762 template <typename PipelineBinaryKHRAllocator = std::allocator<PipelineBinaryKHR>,
|
|
|
17763 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17764 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, PipelineBinaryKHR>::value, int>::type = 0,
|
|
|
17765 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17766 VULKAN_HPP_NODISCARD ResultValue<std::vector<PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
|
|
|
17767 createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo,
|
|
|
17768 Optional<const AllocationCallbacks> allocator,
|
|
|
17769 PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
|
|
|
17770 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17771 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
17772 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
|
|
|
17773 template <
|
|
|
17774 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17775 typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<PipelineBinaryKHR, Dispatch>>,
|
|
|
17776 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<PipelineBinaryKHR, Dispatch>>::value, int>::type = 0,
|
|
|
17777 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17778 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
|
|
|
17779 createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo,
|
|
|
17780 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17781 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17782 // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html
|
|
|
17783 template <
|
|
|
17784 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17785 typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<PipelineBinaryKHR, Dispatch>>,
|
|
|
17786 typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<PipelineBinaryKHR, Dispatch>>::value, int>::type = 0,
|
|
|
17787 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17788 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
|
|
|
17789 createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo,
|
|
|
17790 Optional<const AllocationCallbacks> allocator,
|
|
|
17791 PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator,
|
|
|
17792 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17793 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
17794 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17795
|
|
|
17796 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
|
|
|
17797 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17798 void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary,
|
|
|
17799 const AllocationCallbacks * pAllocator,
|
|
|
17800 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17802 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
|
|
|
17803 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17804 void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
17805 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17806 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17807 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17808
|
|
|
17809 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
|
|
|
17810 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17811 void destroy( PipelineBinaryKHR pipelineBinary,
|
|
|
17812 const AllocationCallbacks * pAllocator,
|
|
|
17813 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17814 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17815 // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html
|
|
|
17816 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17817 void destroy( PipelineBinaryKHR pipelineBinary,
|
|
|
17818 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17819 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17821
|
|
|
17822 // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html
|
|
|
17823 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17824 VULKAN_HPP_NODISCARD Result getPipelineKeyKHR( const PipelineCreateInfoKHR * pPipelineCreateInfo,
|
|
|
17825 PipelineBinaryKeyKHR * pPipelineKey,
|
|
|
17826 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17827 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17828 // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html
|
|
|
17829 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17830 VULKAN_HPP_NODISCARD typename ResultValueType<PipelineBinaryKeyKHR>::type
|
|
|
17831 getPipelineKeyKHR( Optional<const PipelineCreateInfoKHR> pipelineCreateInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17832 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17833 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17834
|
|
|
17835 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
|
|
|
17836 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17837 VULKAN_HPP_NODISCARD Result getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR * pInfo,
|
|
|
17838 PipelineBinaryKeyKHR * pPipelineBinaryKey,
|
|
|
17839 size_t * pPipelineBinaryDataSize,
|
|
|
17840 void * pPipelineBinaryData,
|
|
|
17841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17843 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
|
|
|
17844 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
17845 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17846 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
17847 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17848 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
|
|
|
17849 getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17850 // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html
|
|
|
17851 template <typename Uint8_tAllocator = std::allocator<uint8_t>,
|
|
|
17852 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17853 typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0,
|
|
|
17854 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17855 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getPipelineBinaryDataKHR(
|
|
|
17856 const PipelineBinaryDataInfoKHR & info, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17858
|
|
|
17859 // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
|
|
|
17860 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
|
|
|
17861 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17862 VULKAN_HPP_NODISCARD Result releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo,
|
|
|
17863 const AllocationCallbacks * pAllocator,
|
|
|
17864 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17866 // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
|
|
|
17867 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
|
|
|
17868 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17869 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
17870 releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info,
|
|
|
17871 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
17872 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17873 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17874
|
|
|
17875 //=== VK_QCOM_tile_properties ===
|
|
|
17876
|
|
|
17877 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
|
|
|
17878 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
|
|
|
17879 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17880 VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( Framebuffer framebuffer,
|
|
|
17881 uint32_t * pPropertiesCount,
|
|
|
17882 TilePropertiesQCOM * pProperties,
|
|
|
17883 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17884 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17885 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
|
|
|
17886 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
|
|
|
17887 template <typename TilePropertiesQCOMAllocator = std::allocator<TilePropertiesQCOM>,
|
|
|
17888 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17889 typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, TilePropertiesQCOM>::value, int>::type = 0,
|
|
|
17890 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17891 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
|
|
|
17892 getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17893 // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
|
|
|
17894 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html
|
|
|
17895 template <typename TilePropertiesQCOMAllocator = std::allocator<TilePropertiesQCOM>,
|
|
|
17896 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17897 typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, TilePropertiesQCOM>::value, int>::type = 0,
|
|
|
17898 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17899 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM(
|
|
|
17900 Framebuffer framebuffer, TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17902
|
|
|
17903 // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
|
|
|
17904 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
|
|
|
17905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17906 VULKAN_HPP_NODISCARD Result getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo,
|
|
|
17907 TilePropertiesQCOM * pProperties,
|
|
|
17908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17910 // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
|
|
|
17911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
|
|
|
17912 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17913 VULKAN_HPP_NODISCARD typename ResultValueType<TilePropertiesQCOM>::type
|
|
|
17914 getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17915 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17916
|
|
|
17917 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
17918
|
|
|
17919 // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
|
|
|
17920 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17921 VULKAN_HPP_NODISCARD Result releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo,
|
|
|
17922 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17923 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17924 // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
|
|
|
17925 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17926 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
17927 releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17928 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17929
|
|
|
17930 //=== VK_NV_cooperative_vector ===
|
|
|
17931
|
|
|
17932 // wrapper function for command vkConvertCooperativeVectorMatrixNV, see
|
|
|
17933 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html
|
|
|
17934 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17935 VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV * pInfo,
|
|
|
17936 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17937 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17938 // wrapper function for command vkConvertCooperativeVectorMatrixNV, see
|
|
|
17939 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html
|
|
|
17940 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17941 VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info,
|
|
|
17942 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17943 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17944
|
|
|
17945 //=== VK_NV_low_latency2 ===
|
|
|
17946
|
|
|
17947 // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
|
|
|
17948 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17949 VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( SwapchainKHR swapchain,
|
|
|
17950 const LatencySleepModeInfoNV * pSleepModeInfo,
|
|
|
17951 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17953 // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
|
|
|
17954 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17955 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setLatencySleepModeNV(
|
|
|
17956 SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17957 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17958
|
|
|
17959 // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
|
|
|
17960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17961 VULKAN_HPP_NODISCARD Result latencySleepNV( SwapchainKHR swapchain,
|
|
|
17962 const LatencySleepInfoNV * pSleepInfo,
|
|
|
17963 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17965 // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
|
|
|
17966 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17967 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
17968 latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17970
|
|
|
17971 // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html
|
|
|
17972 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17973 void setLatencyMarkerNV( SwapchainKHR swapchain,
|
|
|
17974 const SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
|
|
|
17975 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17976 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17977 // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html
|
|
|
17978 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17979 void setLatencyMarkerNV( SwapchainKHR swapchain,
|
|
|
17980 const SetLatencyMarkerInfoNV & latencyMarkerInfo,
|
|
|
17981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
17983
|
|
|
17984 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
|
|
|
17985 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17986 void getLatencyTimingsNV( SwapchainKHR swapchain,
|
|
|
17987 GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
|
|
|
17988 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
17989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
17990 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
|
|
|
17991 template <
|
|
|
17992 typename LatencyTimingsFrameReportNVAllocator = std::allocator<LatencyTimingsFrameReportNV>,
|
|
|
17993 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
17994 typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, LatencyTimingsFrameReportNV>::value, int>::type = 0,
|
|
|
17995 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
17996 VULKAN_HPP_NODISCARD std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
|
|
|
17997 getLatencyTimingsNV( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
17998 // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html
|
|
|
17999 template <
|
|
|
18000 typename LatencyTimingsFrameReportNVAllocator = std::allocator<LatencyTimingsFrameReportNV>,
|
|
|
18001 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18002 typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, LatencyTimingsFrameReportNV>::value, int>::type = 0,
|
|
|
18003 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18004 VULKAN_HPP_NODISCARD std::vector<LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
|
|
|
18005 getLatencyTimingsNV( SwapchainKHR swapchain,
|
|
|
18006 LatencyTimingsFrameReportNVAllocator & latencyTimingsFrameReportNVAllocator,
|
|
|
18007 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18008 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18009
|
|
|
18010 //=== VK_ARM_data_graph ===
|
|
|
18011
|
|
|
18012 // wrapper function for command vkCreateDataGraphPipelinesARM, see
|
|
|
18013 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
|
|
|
18014 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18015 VULKAN_HPP_NODISCARD Result createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
|
|
|
18016 PipelineCache pipelineCache,
|
|
|
18017 uint32_t createInfoCount,
|
|
|
18018 const DataGraphPipelineCreateInfoARM * pCreateInfos,
|
|
|
18019 const AllocationCallbacks * pAllocator,
|
|
|
18020 Pipeline * pPipelines,
|
|
|
18021 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18023 // wrapper function for command vkCreateDataGraphPipelinesARM, see
|
|
|
18024 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
|
|
|
18025 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
18026 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18027 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
18028 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18029 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
18030 createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
|
|
|
18031 PipelineCache pipelineCache,
|
|
|
18032 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
|
|
|
18033 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18034 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18035 // wrapper function for command vkCreateDataGraphPipelinesARM, see
|
|
|
18036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
|
|
|
18037 template <typename PipelineAllocator = std::allocator<Pipeline>,
|
|
|
18038 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18039 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, Pipeline>::value, int>::type = 0,
|
|
|
18040 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18041 VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
|
|
|
18042 createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation,
|
|
|
18043 PipelineCache pipelineCache,
|
|
|
18044 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
|
|
|
18045 Optional<const AllocationCallbacks> allocator,
|
|
|
18046 PipelineAllocator & pipelineAllocator,
|
|
|
18047 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18048 // wrapper function for command vkCreateDataGraphPipelinesARM, see
|
|
|
18049 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
|
|
|
18050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18051 VULKAN_HPP_NODISCARD ResultValue<Pipeline>
|
|
|
18052 createDataGraphPipelineARM( DeferredOperationKHR deferredOperation,
|
|
|
18053 PipelineCache pipelineCache,
|
|
|
18054 const DataGraphPipelineCreateInfoARM & createInfo,
|
|
|
18055 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18057 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
18058 // wrapper function for command vkCreateDataGraphPipelinesARM, see
|
|
|
18059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
|
|
|
18060 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18061 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
18062 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
18063 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18064 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
18065 createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation,
|
|
|
18066 PipelineCache pipelineCache,
|
|
|
18067 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
|
|
|
18068 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18069 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18070 // wrapper function for command vkCreateDataGraphPipelinesARM, see
|
|
|
18071 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
|
|
|
18072 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18073 typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
|
|
|
18074 typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0,
|
|
|
18075 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18076 VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
|
|
|
18077 createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation,
|
|
|
18078 PipelineCache pipelineCache,
|
|
|
18079 ArrayProxy<const DataGraphPipelineCreateInfoARM> const & createInfos,
|
|
|
18080 Optional<const AllocationCallbacks> allocator,
|
|
|
18081 PipelineAllocator & pipelineAllocator,
|
|
|
18082 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18083 // wrapper function for command vkCreateDataGraphPipelinesARM, see
|
|
|
18084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html
|
|
|
18085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18086 VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
|
|
|
18087 createDataGraphPipelineARMUnique( DeferredOperationKHR deferredOperation,
|
|
|
18088 PipelineCache pipelineCache,
|
|
|
18089 const DataGraphPipelineCreateInfoARM & createInfo,
|
|
|
18090 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18091 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18092 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
18093 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18094
|
|
|
18095 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
|
|
|
18096 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
|
|
|
18097 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18098 VULKAN_HPP_NODISCARD Result createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM * pCreateInfo,
|
|
|
18099 const AllocationCallbacks * pAllocator,
|
|
|
18100 DataGraphPipelineSessionARM * pSession,
|
|
|
18101 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18102 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18103 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
|
|
|
18104 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
|
|
|
18105 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18106 VULKAN_HPP_NODISCARD typename ResultValueType<DataGraphPipelineSessionARM>::type
|
|
|
18107 createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM & createInfo,
|
|
|
18108 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18109 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18110 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
18111 // wrapper function for command vkCreateDataGraphPipelineSessionARM, see
|
|
|
18112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html
|
|
|
18113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18114 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DataGraphPipelineSessionARM, Dispatch>>::type
|
|
|
18115 createDataGraphPipelineSessionARMUnique( const DataGraphPipelineSessionCreateInfoARM & createInfo,
|
|
|
18116 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18117 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18118 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
18119 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18120
|
|
|
18121 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
|
|
|
18122 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
|
|
|
18123 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18124 VULKAN_HPP_NODISCARD Result
|
|
|
18125 getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo,
|
|
|
18126 uint32_t * pBindPointRequirementCount,
|
|
|
18127 DataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements,
|
|
|
18128 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18129 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18130 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
|
|
|
18131 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
|
|
|
18132 template <typename DataGraphPipelineSessionBindPointRequirementARMAllocator = std::allocator<DataGraphPipelineSessionBindPointRequirementARM>,
|
|
|
18133 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18134 typename std::enable_if<std::is_same<typename DataGraphPipelineSessionBindPointRequirementARMAllocator::value_type,
|
|
|
18135 DataGraphPipelineSessionBindPointRequirementARM>::value,
|
|
|
18136 int>::type = 0,
|
|
|
18137 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18138 VULKAN_HPP_NODISCARD
|
|
|
18139 typename ResultValueType<std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator>>::type
|
|
|
18140 getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info,
|
|
|
18141 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18142 // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see
|
|
|
18143 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html
|
|
|
18144 template <typename DataGraphPipelineSessionBindPointRequirementARMAllocator = std::allocator<DataGraphPipelineSessionBindPointRequirementARM>,
|
|
|
18145 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18146 typename std::enable_if<std::is_same<typename DataGraphPipelineSessionBindPointRequirementARMAllocator::value_type,
|
|
|
18147 DataGraphPipelineSessionBindPointRequirementARM>::value,
|
|
|
18148 int>::type = 0,
|
|
|
18149 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18150 VULKAN_HPP_NODISCARD
|
|
|
18151 typename ResultValueType<std::vector<DataGraphPipelineSessionBindPointRequirementARM, DataGraphPipelineSessionBindPointRequirementARMAllocator>>::type
|
|
|
18152 getDataGraphPipelineSessionBindPointRequirementsARM(
|
|
|
18153 const DataGraphPipelineSessionBindPointRequirementsInfoARM & info,
|
|
|
18154 DataGraphPipelineSessionBindPointRequirementARMAllocator & dataGraphPipelineSessionBindPointRequirementARMAllocator,
|
|
|
18155 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18156 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18157
|
|
|
18158 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
|
|
|
18159 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
|
|
|
18160 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18161 void getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo,
|
|
|
18162 MemoryRequirements2 * pMemoryRequirements,
|
|
|
18163 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18164 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18165 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
|
|
|
18166 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
|
|
|
18167 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18168 VULKAN_HPP_NODISCARD MemoryRequirements2 getDataGraphPipelineSessionMemoryRequirementsARM(
|
|
|
18169 const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18170 // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see
|
|
|
18171 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html
|
|
|
18172 template <typename X,
|
|
|
18173 typename Y,
|
|
|
18174 typename... Z,
|
|
|
18175 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18176 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18177 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
18178 getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info,
|
|
|
18179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18181
|
|
|
18182 // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see
|
|
|
18183 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html
|
|
|
18184 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18185 VULKAN_HPP_NODISCARD Result bindDataGraphPipelineSessionMemoryARM( uint32_t bindInfoCount,
|
|
|
18186 const BindDataGraphPipelineSessionMemoryInfoARM * pBindInfos,
|
|
|
18187 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18189 // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see
|
|
|
18190 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html
|
|
|
18191 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18192 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
18193 bindDataGraphPipelineSessionMemoryARM( ArrayProxy<const BindDataGraphPipelineSessionMemoryInfoARM> const & bindInfos,
|
|
|
18194 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18196
|
|
|
18197 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
|
|
|
18198 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
|
|
|
18199 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18200 void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session,
|
|
|
18201 const AllocationCallbacks * pAllocator,
|
|
|
18202 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18204 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
|
|
|
18205 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
|
|
|
18206 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18207 void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session,
|
|
|
18208 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18209 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18211
|
|
|
18212 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
|
|
|
18213 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
|
|
|
18214 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18215 void destroy( DataGraphPipelineSessionARM session,
|
|
|
18216 const AllocationCallbacks * pAllocator,
|
|
|
18217 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18219 // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see
|
|
|
18220 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html
|
|
|
18221 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18222 void destroy( DataGraphPipelineSessionARM session,
|
|
|
18223 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18224 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18226
|
|
|
18227 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
|
|
|
18228 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
|
|
|
18229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18230 VULKAN_HPP_NODISCARD Result
|
|
|
18231 getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo,
|
|
|
18232 uint32_t * pPropertiesCount,
|
|
|
18233 DataGraphPipelinePropertyARM * pProperties,
|
|
|
18234 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18235 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18236 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
|
|
|
18237 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
|
|
|
18238 template <
|
|
|
18239 typename DataGraphPipelinePropertyARMAllocator = std::allocator<DataGraphPipelinePropertyARM>,
|
|
|
18240 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18241 typename std::enable_if<std::is_same<typename DataGraphPipelinePropertyARMAllocator::value_type, DataGraphPipelinePropertyARM>::value, int>::type = 0,
|
|
|
18242 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18243 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator>>::type
|
|
|
18244 getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo,
|
|
|
18245 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18246 // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see
|
|
|
18247 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html
|
|
|
18248 template <
|
|
|
18249 typename DataGraphPipelinePropertyARMAllocator = std::allocator<DataGraphPipelinePropertyARM>,
|
|
|
18250 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18251 typename std::enable_if<std::is_same<typename DataGraphPipelinePropertyARMAllocator::value_type, DataGraphPipelinePropertyARM>::value, int>::type = 0,
|
|
|
18252 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18253 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataGraphPipelinePropertyARM, DataGraphPipelinePropertyARMAllocator>>::type
|
|
|
18254 getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo,
|
|
|
18255 DataGraphPipelinePropertyARMAllocator & dataGraphPipelinePropertyARMAllocator,
|
|
|
18256 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18258
|
|
|
18259 // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see
|
|
|
18260 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html
|
|
|
18261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18262 VULKAN_HPP_NODISCARD Result getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo,
|
|
|
18263 uint32_t propertiesCount,
|
|
|
18264 DataGraphPipelinePropertyQueryResultARM * pProperties,
|
|
|
18265 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18266
|
|
|
18267 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
18268 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
18269
|
|
|
18270 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
|
|
|
18271 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
|
|
|
18272 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18273 VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer,
|
|
|
18274 ScreenBufferPropertiesQNX * pProperties,
|
|
|
18275 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18276 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18277 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
|
|
|
18278 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
|
|
|
18279 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18280 VULKAN_HPP_NODISCARD typename ResultValueType<ScreenBufferPropertiesQNX>::type
|
|
|
18281 getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18282 // wrapper function for command vkGetScreenBufferPropertiesQNX, see
|
|
|
18283 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html
|
|
|
18284 template <typename X,
|
|
|
18285 typename Y,
|
|
|
18286 typename... Z,
|
|
|
18287 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18288 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18289 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
18290 getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18291 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18292 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
18293
|
|
|
18294 //=== VK_KHR_calibrated_timestamps ===
|
|
|
18295
|
|
|
18296 // wrapper function for command vkGetCalibratedTimestampsKHR, see
|
|
|
18297 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
|
|
|
18298 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18299 VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t timestampCount,
|
|
|
18300 const CalibratedTimestampInfoKHR * pTimestampInfos,
|
|
|
18301 uint64_t * pTimestamps,
|
|
|
18302 uint64_t * pMaxDeviation,
|
|
|
18303 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18304 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18305 // wrapper function for command vkGetCalibratedTimestampsKHR, see
|
|
|
18306 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
|
|
|
18307 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
|
|
|
18308 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18309 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
|
|
|
18310 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18311 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
|
|
18312 getCalibratedTimestampsKHR( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
|
|
|
18313 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18314 // wrapper function for command vkGetCalibratedTimestampsKHR, see
|
|
|
18315 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
|
|
|
18316 template <typename Uint64_tAllocator = std::allocator<uint64_t>,
|
|
|
18317 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18318 typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0,
|
|
|
18319 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18320 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
|
|
|
18321 getCalibratedTimestampsKHR( ArrayProxy<const CalibratedTimestampInfoKHR> const & timestampInfos,
|
|
|
18322 Uint64_tAllocator & uint64_tAllocator,
|
|
|
18323 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18324 // wrapper function for command vkGetCalibratedTimestampsKHR, see
|
|
|
18325 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html
|
|
|
18326 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18327 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
|
|
|
18328 getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18329 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18330
|
|
|
18331 //=== VK_NV_external_compute_queue ===
|
|
|
18332
|
|
|
18333 // wrapper function for command vkCreateExternalComputeQueueNV, see
|
|
|
18334 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
|
|
|
18335 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18336 VULKAN_HPP_NODISCARD Result createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV * pCreateInfo,
|
|
|
18337 const AllocationCallbacks * pAllocator,
|
|
|
18338 ExternalComputeQueueNV * pExternalQueue,
|
|
|
18339 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18340 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18341 // wrapper function for command vkCreateExternalComputeQueueNV, see
|
|
|
18342 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
|
|
|
18343 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18344 VULKAN_HPP_NODISCARD typename ResultValueType<ExternalComputeQueueNV>::type
|
|
|
18345 createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV & createInfo,
|
|
|
18346 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18347 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18348 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
18349 // wrapper function for command vkCreateExternalComputeQueueNV, see
|
|
|
18350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
|
|
|
18351 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18352 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<ExternalComputeQueueNV, Dispatch>>::type
|
|
|
18353 createExternalComputeQueueNVUnique( const ExternalComputeQueueCreateInfoNV & createInfo,
|
|
|
18354 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18355 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18356 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
18357 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18358
|
|
|
18359 // wrapper function for command vkDestroyExternalComputeQueueNV, see
|
|
|
18360 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
|
|
|
18361 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18362 void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue,
|
|
|
18363 const AllocationCallbacks * pAllocator,
|
|
|
18364 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18365 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18366 // wrapper function for command vkDestroyExternalComputeQueueNV, see
|
|
|
18367 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
|
|
|
18368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18369 void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue,
|
|
|
18370 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18373
|
|
|
18374 // wrapper function for command vkDestroyExternalComputeQueueNV, see
|
|
|
18375 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
|
|
|
18376 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18377 void destroy( ExternalComputeQueueNV externalQueue,
|
|
|
18378 const AllocationCallbacks * pAllocator,
|
|
|
18379 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18381 // wrapper function for command vkDestroyExternalComputeQueueNV, see
|
|
|
18382 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
|
|
|
18383 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18384 void destroy( ExternalComputeQueueNV externalQueue,
|
|
|
18385 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18386 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18387 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18388
|
|
|
18389 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
18390
|
|
|
18391 // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
|
|
|
18392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html
|
|
|
18393 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18394 void getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV * pInfo,
|
|
|
18395 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
|
|
|
18396 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18398 // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
|
|
|
18399 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html
|
|
|
18400 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18401 VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getClusterAccelerationStructureBuildSizesNV(
|
|
|
18402 const ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18403 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18404
|
|
|
18405 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
18406
|
|
|
18407 // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see
|
|
|
18408 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html
|
|
|
18409 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18410 void getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV * pInfo,
|
|
|
18411 AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
|
|
|
18412 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18414 // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see
|
|
|
18415 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html
|
|
|
18416 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18417 VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getPartitionedAccelerationStructuresBuildSizesNV(
|
|
|
18418 const PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18420
|
|
|
18421 //=== VK_EXT_device_generated_commands ===
|
|
|
18422
|
|
|
18423 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
|
|
|
18424 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
|
|
|
18425 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18426 void getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT * pInfo,
|
|
|
18427 MemoryRequirements2 * pMemoryRequirements,
|
|
|
18428 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18430 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
|
|
|
18431 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
|
|
|
18432 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18433 VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsEXT(
|
|
|
18434 const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18435 // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see
|
|
|
18436 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html
|
|
|
18437 template <typename X,
|
|
|
18438 typename Y,
|
|
|
18439 typename... Z,
|
|
|
18440 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18441 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18442 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
18443 getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info,
|
|
|
18444 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18446
|
|
|
18447 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
|
|
|
18448 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
|
|
|
18449 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18450 VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT * pCreateInfo,
|
|
|
18451 const AllocationCallbacks * pAllocator,
|
|
|
18452 IndirectCommandsLayoutEXT * pIndirectCommandsLayout,
|
|
|
18453 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18455 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
|
|
|
18456 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
|
|
|
18457 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18458 VULKAN_HPP_NODISCARD typename ResultValueType<IndirectCommandsLayoutEXT>::type
|
|
|
18459 createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT & createInfo,
|
|
|
18460 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18461 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18462 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
18463 // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see
|
|
|
18464 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html
|
|
|
18465 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18466 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<IndirectCommandsLayoutEXT, Dispatch>>::type
|
|
|
18467 createIndirectCommandsLayoutEXTUnique( const IndirectCommandsLayoutCreateInfoEXT & createInfo,
|
|
|
18468 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18469 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18470 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
18471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18472
|
|
|
18473 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
|
|
|
18474 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
|
|
|
18475 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18476 void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout,
|
|
|
18477 const AllocationCallbacks * pAllocator,
|
|
|
18478 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18480 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
|
|
|
18481 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
|
|
|
18482 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18483 void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
18484 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18485 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18486 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18487
|
|
|
18488 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
|
|
|
18489 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
|
|
|
18490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18491 void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout,
|
|
|
18492 const AllocationCallbacks * pAllocator,
|
|
|
18493 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18495 // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see
|
|
|
18496 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html
|
|
|
18497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18498 void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout,
|
|
|
18499 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18500 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18502
|
|
|
18503 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
|
|
|
18504 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
|
|
|
18505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18506 VULKAN_HPP_NODISCARD Result createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT * pCreateInfo,
|
|
|
18507 const AllocationCallbacks * pAllocator,
|
|
|
18508 IndirectExecutionSetEXT * pIndirectExecutionSet,
|
|
|
18509 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18511 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
|
|
|
18512 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
|
|
|
18513 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18514 VULKAN_HPP_NODISCARD typename ResultValueType<IndirectExecutionSetEXT>::type
|
|
|
18515 createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT & createInfo,
|
|
|
18516 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18517 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18518 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
18519 // wrapper function for command vkCreateIndirectExecutionSetEXT, see
|
|
|
18520 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html
|
|
|
18521 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18522 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<IndirectExecutionSetEXT, Dispatch>>::type
|
|
|
18523 createIndirectExecutionSetEXTUnique( const IndirectExecutionSetCreateInfoEXT & createInfo,
|
|
|
18524 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18525 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18526 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
18527 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18528
|
|
|
18529 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
|
|
|
18530 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
|
|
|
18531 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18532 void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet,
|
|
|
18533 const AllocationCallbacks * pAllocator,
|
|
|
18534 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18535 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18536 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
|
|
|
18537 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
|
|
|
18538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18539 void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
18540 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18541 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18543
|
|
|
18544 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
|
|
|
18545 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
|
|
|
18546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18547 void destroy( IndirectExecutionSetEXT indirectExecutionSet,
|
|
|
18548 const AllocationCallbacks * pAllocator,
|
|
|
18549 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18551 // wrapper function for command vkDestroyIndirectExecutionSetEXT, see
|
|
|
18552 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html
|
|
|
18553 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18554 void destroy( IndirectExecutionSetEXT indirectExecutionSet,
|
|
|
18555 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18556 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18558
|
|
|
18559 // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see
|
|
|
18560 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html
|
|
|
18561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18562 void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet,
|
|
|
18563 uint32_t executionSetWriteCount,
|
|
|
18564 const WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites,
|
|
|
18565 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18567 // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see
|
|
|
18568 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html
|
|
|
18569 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18570 void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet,
|
|
|
18571 ArrayProxy<const WriteIndirectExecutionSetPipelineEXT> const & executionSetWrites,
|
|
|
18572 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18574
|
|
|
18575 // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see
|
|
|
18576 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html
|
|
|
18577 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18578 void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet,
|
|
|
18579 uint32_t executionSetWriteCount,
|
|
|
18580 const WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites,
|
|
|
18581 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18583 // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see
|
|
|
18584 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html
|
|
|
18585 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18586 void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet,
|
|
|
18587 ArrayProxy<const WriteIndirectExecutionSetShaderEXT> const & executionSetWrites,
|
|
|
18588 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18589 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18590
|
|
|
18591 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
18592 //=== VK_OHOS_native_buffer ===
|
|
|
18593
|
|
|
18594 // wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
|
|
|
18595 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
|
|
|
18596 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18597 VULKAN_HPP_NODISCARD Result getSwapchainGrallocUsageOHOS( Format format,
|
|
|
18598 ImageUsageFlags imageUsage,
|
|
|
18599 uint64_t * grallocUsage,
|
|
|
18600 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18601 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18602 // wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
|
|
|
18603 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
|
|
|
18604 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18605 VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
|
|
|
18606 getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18607 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18608
|
|
|
18609 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18610 // wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
|
|
|
18611 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18612 VULKAN_HPP_NODISCARD Result acquireImageOHOS( Image image,
|
|
|
18613 int32_t nativeFenceFd,
|
|
|
18614 Semaphore semaphore,
|
|
|
18615 Fence fence,
|
|
|
18616 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18617 # else
|
|
|
18618 // wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
|
|
|
18619 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18620 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
18621 acquireImageOHOS( Image image,
|
|
|
18622 int32_t nativeFenceFd,
|
|
|
18623 Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
18624 Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
18625 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18626 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
18627 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
18628
|
|
|
18629 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
18630 //=== VK_EXT_external_memory_metal ===
|
|
|
18631
|
|
|
18632 // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html
|
|
|
18633 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18634 VULKAN_HPP_NODISCARD Result getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo,
|
|
|
18635 void ** pHandle,
|
|
|
18636 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18637 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18638 // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html
|
|
|
18639 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18640 VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo,
|
|
|
18641 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18642 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18643
|
|
|
18644 // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see
|
|
|
18645 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html
|
|
|
18646 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18647 VULKAN_HPP_NODISCARD Result getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType,
|
|
|
18648 const void * pHandle,
|
|
|
18649 MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties,
|
|
|
18650 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18651 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18652 // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see
|
|
|
18653 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html
|
|
|
18654 template <typename HandleType,
|
|
|
18655 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18656 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18657 VULKAN_HPP_NODISCARD typename ResultValueType<MemoryMetalHandlePropertiesEXT>::type getMemoryMetalHandlePropertiesEXT(
|
|
|
18658 ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18659 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18660 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
18661
|
|
|
18662 operator VkDevice() const VULKAN_HPP_NOEXCEPT
|
|
|
18663 {
|
|
|
18664 return m_device;
|
|
|
18665 }
|
|
|
18666
|
|
|
18667 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
18668 {
|
|
|
18669 return m_device != VK_NULL_HANDLE;
|
|
|
18670 }
|
|
|
18671
|
|
|
18672 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
18673 {
|
|
|
18674 return m_device == VK_NULL_HANDLE;
|
|
|
18675 }
|
|
|
18676
|
|
|
18677 private:
|
|
|
18678 VkDevice m_device = {};
|
|
|
18679 };
|
|
|
18680
|
|
|
18681 template <>
|
|
|
18682 struct CppType<ObjectType, ObjectType::eDevice>
|
|
|
18683 {
|
|
|
18684 using Type = Device;
|
|
|
18685 };
|
|
|
18686
|
|
|
18687 template <>
|
|
|
18688 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDevice>
|
|
|
18689 {
|
|
|
18690 using Type = Device;
|
|
|
18691 };
|
|
|
18692
|
|
|
18693 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
18694 template <>
|
|
|
18695 struct CppType<VkDevice, VK_NULL_HANDLE>
|
|
|
18696 {
|
|
|
18697 using Type = Device;
|
|
|
18698 };
|
|
|
18699 #endif
|
|
|
18700
|
|
|
18701 template <>
|
|
|
18702 struct isVulkanHandleType<Device>
|
|
|
18703 {
|
|
|
18704 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
18705 };
|
|
|
18706
|
|
|
18707 // wrapper class for handle VkDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeKHR.html
|
|
|
18708 class DisplayModeKHR
|
|
|
18709 {
|
|
|
18710 public:
|
|
|
18711 using CType = VkDisplayModeKHR;
|
|
|
18712 using NativeType = VkDisplayModeKHR;
|
|
|
18713
|
|
|
18714 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR;
|
|
|
18715 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayModeKHR;
|
|
|
18716
|
|
|
18717 public:
|
|
|
18718 DisplayModeKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
18719
|
|
|
18720 DisplayModeKHR( DisplayModeKHR const & rhs ) = default;
|
|
|
18721 DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;
|
|
|
18722
|
|
|
18723 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
18724 DisplayModeKHR( DisplayModeKHR && rhs ) = default;
|
|
|
18725 DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default;
|
|
|
18726 #else
|
|
|
18727 DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( exchange( rhs.m_displayModeKHR, {} ) ) {}
|
|
|
18728
|
|
|
18729 DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
18730 {
|
|
|
18731 m_displayModeKHR = exchange( rhs.m_displayModeKHR, {} );
|
|
|
18732 return *this;
|
|
|
18733 }
|
|
|
18734 #endif
|
|
|
18735
|
|
|
18736 VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
18737
|
|
|
18738 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
|
|
|
18739
|
|
|
18740 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
|
|
18741 DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
|
|
|
18742 {
|
|
|
18743 m_displayModeKHR = displayModeKHR;
|
|
|
18744 return *this;
|
|
|
18745 }
|
|
|
18746 #endif
|
|
|
18747
|
|
|
18748 DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
18749 {
|
|
|
18750 m_displayModeKHR = {};
|
|
|
18751 return *this;
|
|
|
18752 }
|
|
|
18753
|
|
|
18754 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
|
|
|
18755 {
|
|
|
18756 return m_displayModeKHR;
|
|
|
18757 }
|
|
|
18758
|
|
|
18759 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
18760 {
|
|
|
18761 return m_displayModeKHR != VK_NULL_HANDLE;
|
|
|
18762 }
|
|
|
18763
|
|
|
18764 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
18765 {
|
|
|
18766 return m_displayModeKHR == VK_NULL_HANDLE;
|
|
|
18767 }
|
|
|
18768
|
|
|
18769 private:
|
|
|
18770 VkDisplayModeKHR m_displayModeKHR = {};
|
|
|
18771 };
|
|
|
18772
|
|
|
18773 template <>
|
|
|
18774 struct CppType<ObjectType, ObjectType::eDisplayModeKHR>
|
|
|
18775 {
|
|
|
18776 using Type = DisplayModeKHR;
|
|
|
18777 };
|
|
|
18778
|
|
|
18779 template <>
|
|
|
18780 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eDisplayModeKHR>
|
|
|
18781 {
|
|
|
18782 using Type = DisplayModeKHR;
|
|
|
18783 };
|
|
|
18784
|
|
|
18785 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
18786 template <>
|
|
|
18787 struct CppType<VkDisplayModeKHR, VK_NULL_HANDLE>
|
|
|
18788 {
|
|
|
18789 using Type = DisplayModeKHR;
|
|
|
18790 };
|
|
|
18791 #endif
|
|
|
18792
|
|
|
18793 template <>
|
|
|
18794 struct isVulkanHandleType<DisplayModeKHR>
|
|
|
18795 {
|
|
|
18796 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
18797 };
|
|
|
18798
|
|
|
18799 // wrapper class for handle VkPhysicalDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice.html
|
|
|
18800 class PhysicalDevice
|
|
|
18801 {
|
|
|
18802 public:
|
|
|
18803 using CType = VkPhysicalDevice;
|
|
|
18804 using NativeType = VkPhysicalDevice;
|
|
|
18805
|
|
|
18806 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice;
|
|
|
18807 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePhysicalDevice;
|
|
|
18808
|
|
|
18809 public:
|
|
|
18810 PhysicalDevice() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
18811
|
|
|
18812 PhysicalDevice( PhysicalDevice const & rhs ) = default;
|
|
|
18813 PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;
|
|
|
18814
|
|
|
18815 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
18816 PhysicalDevice( PhysicalDevice && rhs ) = default;
|
|
|
18817 PhysicalDevice & operator=( PhysicalDevice && rhs ) = default;
|
|
|
18818 #else
|
|
|
18819 PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) {}
|
|
|
18820
|
|
|
18821 PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
18822 {
|
|
|
18823 m_physicalDevice = exchange( rhs.m_physicalDevice, {} );
|
|
|
18824 return *this;
|
|
|
18825 }
|
|
|
18826 #endif
|
|
|
18827
|
|
|
18828 VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
18829
|
|
|
18830 PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
|
|
|
18831
|
|
|
18832 PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
|
|
|
18833 {
|
|
|
18834 m_physicalDevice = physicalDevice;
|
|
|
18835 return *this;
|
|
|
18836 }
|
|
|
18837
|
|
|
18838 PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
18839 {
|
|
|
18840 m_physicalDevice = {};
|
|
|
18841 return *this;
|
|
|
18842 }
|
|
|
18843
|
|
|
18844 //=== VK_VERSION_1_0 ===
|
|
|
18845
|
|
|
18846 // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html
|
|
|
18847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18848 void getFeatures( PhysicalDeviceFeatures * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18850 // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html
|
|
|
18851 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18852 VULKAN_HPP_NODISCARD PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18853 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18854
|
|
|
18855 // wrapper function for command vkGetPhysicalDeviceFormatProperties, see
|
|
|
18856 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html
|
|
|
18857 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18858 void getFormatProperties( Format format,
|
|
|
18859 FormatProperties * pFormatProperties,
|
|
|
18860 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18861 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18862 // wrapper function for command vkGetPhysicalDeviceFormatProperties, see
|
|
|
18863 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html
|
|
|
18864 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18865 VULKAN_HPP_NODISCARD FormatProperties getFormatProperties( Format format,
|
|
|
18866 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18867 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18868
|
|
|
18869 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see
|
|
|
18870 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html
|
|
|
18871 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18872 VULKAN_HPP_NODISCARD Result getImageFormatProperties( Format format,
|
|
|
18873 ImageType type,
|
|
|
18874 ImageTiling tiling,
|
|
|
18875 ImageUsageFlags usage,
|
|
|
18876 ImageCreateFlags flags,
|
|
|
18877 ImageFormatProperties * pImageFormatProperties,
|
|
|
18878 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18879 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18880 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see
|
|
|
18881 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html
|
|
|
18882 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18883 VULKAN_HPP_NODISCARD typename ResultValueType<ImageFormatProperties>::type
|
|
|
18884 getImageFormatProperties( Format format,
|
|
|
18885 ImageType type,
|
|
|
18886 ImageTiling tiling,
|
|
|
18887 ImageUsageFlags usage,
|
|
|
18888 ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
18889 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18890 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18891
|
|
|
18892 // wrapper function for command vkGetPhysicalDeviceProperties, see
|
|
|
18893 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html
|
|
|
18894 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18895 void getProperties( PhysicalDeviceProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18897 // wrapper function for command vkGetPhysicalDeviceProperties, see
|
|
|
18898 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html
|
|
|
18899 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18900 VULKAN_HPP_NODISCARD PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18902
|
|
|
18903 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
|
|
|
18904 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
|
|
|
18905 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18906 void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount,
|
|
|
18907 QueueFamilyProperties * pQueueFamilyProperties,
|
|
|
18908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18910 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
|
|
|
18911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
|
|
|
18912 template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
|
|
|
18913 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18914 typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, QueueFamilyProperties>::value, int>::type = 0,
|
|
|
18915 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18916 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
|
|
|
18917 getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18918 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see
|
|
|
18919 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html
|
|
|
18920 template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
|
|
|
18921 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18922 typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, QueueFamilyProperties>::value, int>::type = 0,
|
|
|
18923 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18924 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
|
|
|
18925 getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
|
|
|
18926 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18927 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18928
|
|
|
18929 // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see
|
|
|
18930 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html
|
|
|
18931 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18932 void getMemoryProperties( PhysicalDeviceMemoryProperties * pMemoryProperties,
|
|
|
18933 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18935 // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see
|
|
|
18936 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html
|
|
|
18937 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18938 VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties
|
|
|
18939 getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18941
|
|
|
18942 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
|
|
|
18943 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18944 VULKAN_HPP_NODISCARD Result createDevice( const DeviceCreateInfo * pCreateInfo,
|
|
|
18945 const AllocationCallbacks * pAllocator,
|
|
|
18946 Device * pDevice,
|
|
|
18947 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18948 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18949 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
|
|
|
18950 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18951 VULKAN_HPP_NODISCARD typename ResultValueType<Device>::type
|
|
|
18952 createDevice( const DeviceCreateInfo & createInfo,
|
|
|
18953 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18954 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18955 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
18956 // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html
|
|
|
18957 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18958 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Device, Dispatch>>::type
|
|
|
18959 createDeviceUnique( const DeviceCreateInfo & createInfo,
|
|
|
18960 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18961 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18962 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
18963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18964
|
|
|
18965 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
|
|
|
18966 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
|
|
|
18967 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18968 VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char * pLayerName,
|
|
|
18969 uint32_t * pPropertyCount,
|
|
|
18970 ExtensionProperties * pProperties,
|
|
|
18971 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
18972 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
18973 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
|
|
|
18974 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
|
|
|
18975 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
|
|
|
18976 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18977 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
|
|
|
18978 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18979 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
|
|
|
18980 enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
18981 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18982 // wrapper function for command vkEnumerateDeviceExtensionProperties, see
|
|
|
18983 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html
|
|
|
18984 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
|
|
|
18985 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
18986 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
|
|
|
18987 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18988 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
|
|
|
18989 enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
|
|
|
18990 ExtensionPropertiesAllocator & extensionPropertiesAllocator,
|
|
|
18991 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
18992 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
18993
|
|
|
18994 // wrapper function for command vkEnumerateDeviceLayerProperties, see
|
|
|
18995 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
|
|
|
18996 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
18997 VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount,
|
|
|
18998 LayerProperties * pProperties,
|
|
|
18999 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19000 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19001 // wrapper function for command vkEnumerateDeviceLayerProperties, see
|
|
|
19002 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
|
|
|
19003 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
|
|
|
19004 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19005 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
|
|
|
19006 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19007 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
|
|
|
19008 enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19009 // wrapper function for command vkEnumerateDeviceLayerProperties, see
|
|
|
19010 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html
|
|
|
19011 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
|
|
|
19012 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19013 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
|
|
|
19014 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19015 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
|
|
|
19016 enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19017 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19018
|
|
|
19019 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
|
|
|
19020 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
|
|
|
19021 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19022 void getSparseImageFormatProperties( Format format,
|
|
|
19023 ImageType type,
|
|
|
19024 SampleCountFlagBits samples,
|
|
|
19025 ImageUsageFlags usage,
|
|
|
19026 ImageTiling tiling,
|
|
|
19027 uint32_t * pPropertyCount,
|
|
|
19028 SparseImageFormatProperties * pProperties,
|
|
|
19029 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19031 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
|
|
|
19032 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
|
|
|
19033 template <
|
|
|
19034 typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
|
|
|
19035 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19036 typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, SparseImageFormatProperties>::value, int>::type = 0,
|
|
|
19037 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19038 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
|
|
|
19039 getSparseImageFormatProperties( Format format,
|
|
|
19040 ImageType type,
|
|
|
19041 SampleCountFlagBits samples,
|
|
|
19042 ImageUsageFlags usage,
|
|
|
19043 ImageTiling tiling,
|
|
|
19044 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19045 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see
|
|
|
19046 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html
|
|
|
19047 template <
|
|
|
19048 typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
|
|
|
19049 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19050 typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, SparseImageFormatProperties>::value, int>::type = 0,
|
|
|
19051 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19052 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
|
|
|
19053 getSparseImageFormatProperties( Format format,
|
|
|
19054 ImageType type,
|
|
|
19055 SampleCountFlagBits samples,
|
|
|
19056 ImageUsageFlags usage,
|
|
|
19057 ImageTiling tiling,
|
|
|
19058 SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator,
|
|
|
19059 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19060 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19061
|
|
|
19062 //=== VK_VERSION_1_1 ===
|
|
|
19063
|
|
|
19064 // wrapper function for command vkGetPhysicalDeviceFeatures2, see
|
|
|
19065 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
|
|
|
19066 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19067 void getFeatures2( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19069 // wrapper function for command vkGetPhysicalDeviceFeatures2, see
|
|
|
19070 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
|
|
|
19071 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19072 VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19073 // wrapper function for command vkGetPhysicalDeviceFeatures2, see
|
|
|
19074 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html
|
|
|
19075 template <typename X,
|
|
|
19076 typename Y,
|
|
|
19077 typename... Z,
|
|
|
19078 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19079 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19080 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19081 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19082
|
|
|
19083 // wrapper function for command vkGetPhysicalDeviceProperties2, see
|
|
|
19084 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
|
|
|
19085 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19086 void getProperties2( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19087 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19088 // wrapper function for command vkGetPhysicalDeviceProperties2, see
|
|
|
19089 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
|
|
|
19090 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19091 VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19092 // wrapper function for command vkGetPhysicalDeviceProperties2, see
|
|
|
19093 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html
|
|
|
19094 template <typename X,
|
|
|
19095 typename Y,
|
|
|
19096 typename... Z,
|
|
|
19097 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19098 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19099 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19101
|
|
|
19102 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
|
|
|
19103 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
|
|
|
19104 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19105 void getFormatProperties2( Format format,
|
|
|
19106 FormatProperties2 * pFormatProperties,
|
|
|
19107 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19108 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19109 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
|
|
|
19110 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
|
|
|
19111 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19112 VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2( Format format,
|
|
|
19113 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19114 // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see
|
|
|
19115 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html
|
|
|
19116 template <typename X,
|
|
|
19117 typename Y,
|
|
|
19118 typename... Z,
|
|
|
19119 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19120 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19121 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
19122 getFormatProperties2( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19123 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19124
|
|
|
19125 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
|
|
|
19126 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
|
|
|
19127 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19128 VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
|
|
|
19129 ImageFormatProperties2 * pImageFormatProperties,
|
|
|
19130 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19131 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19132 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
|
|
|
19133 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
|
|
|
19134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19135 VULKAN_HPP_NODISCARD typename ResultValueType<ImageFormatProperties2>::type
|
|
|
19136 getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19137 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see
|
|
|
19138 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html
|
|
|
19139 template <typename X,
|
|
|
19140 typename Y,
|
|
|
19141 typename... Z,
|
|
|
19142 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19143 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19144 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
19145 getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19147
|
|
|
19148 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
|
|
|
19149 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
|
|
|
19150 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19151 void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount,
|
|
|
19152 QueueFamilyProperties2 * pQueueFamilyProperties,
|
|
|
19153 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19155 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
|
|
|
19156 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
|
|
|
19157 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
|
|
|
19158 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19159 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
|
|
|
19160 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19161 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
|
|
|
19162 getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19163 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
|
|
|
19164 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
|
|
|
19165 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
|
|
|
19166 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19167 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
|
|
|
19168 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19169 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
|
|
|
19170 getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
|
|
|
19171 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19172 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
|
|
|
19173 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
|
|
|
19174 template <typename StructureChain,
|
|
|
19175 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
19176 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19177 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
19178 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19179 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
|
|
|
19180 getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19181 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see
|
|
|
19182 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html
|
|
|
19183 template <typename StructureChain,
|
|
|
19184 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
19185 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19186 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
19187 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19188 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
|
|
|
19189 getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19190 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19191
|
|
|
19192 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
|
|
|
19193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
|
|
|
19194 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19195 void getMemoryProperties2( PhysicalDeviceMemoryProperties2 * pMemoryProperties,
|
|
|
19196 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19198 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
|
|
|
19199 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
|
|
|
19200 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19201 VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2
|
|
|
19202 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19203 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see
|
|
|
19204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html
|
|
|
19205 template <typename X,
|
|
|
19206 typename Y,
|
|
|
19207 typename... Z,
|
|
|
19208 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19209 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19210 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
19211 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19212 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19213
|
|
|
19214 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
|
|
|
19215 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
|
|
|
19216 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19217 void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
|
|
|
19218 uint32_t * pPropertyCount,
|
|
|
19219 SparseImageFormatProperties2 * pProperties,
|
|
|
19220 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19221 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19222 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
|
|
|
19223 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
|
|
|
19224 template <
|
|
|
19225 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
|
|
|
19226 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19227 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
|
|
|
19228 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19229 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
|
|
|
19230 getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
|
|
|
19231 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19232 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see
|
|
|
19233 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html
|
|
|
19234 template <
|
|
|
19235 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
|
|
|
19236 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19237 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
|
|
|
19238 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19239 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
|
|
|
19240 getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
|
|
|
19241 SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
|
|
|
19242 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19244
|
|
|
19245 // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see
|
|
|
19246 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html
|
|
|
19247 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19248 void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
|
|
|
19249 ExternalBufferProperties * pExternalBufferProperties,
|
|
|
19250 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19252 // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see
|
|
|
19253 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html
|
|
|
19254 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19255 VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferProperties(
|
|
|
19256 const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19258
|
|
|
19259 // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see
|
|
|
19260 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html
|
|
|
19261 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19262 void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
|
|
|
19263 ExternalFenceProperties * pExternalFenceProperties,
|
|
|
19264 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19266 // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see
|
|
|
19267 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html
|
|
|
19268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19269 VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFenceProperties(
|
|
|
19270 const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19271 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19272
|
|
|
19273 // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see
|
|
|
19274 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html
|
|
|
19275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19276 void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
|
|
|
19277 ExternalSemaphoreProperties * pExternalSemaphoreProperties,
|
|
|
19278 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19280 // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see
|
|
|
19281 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html
|
|
|
19282 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19283 VULKAN_HPP_NODISCARD ExternalSemaphoreProperties
|
|
|
19284 getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
|
|
|
19285 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19287
|
|
|
19288 //=== VK_VERSION_1_3 ===
|
|
|
19289
|
|
|
19290 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
|
|
|
19291 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
|
|
|
19292 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19293 VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount,
|
|
|
19294 PhysicalDeviceToolProperties * pToolProperties,
|
|
|
19295 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19296 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19297 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
|
|
|
19298 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
|
|
|
19299 template <
|
|
|
19300 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
|
|
|
19301 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19302 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
|
|
|
19303 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19304 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
|
|
|
19305 getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19306 // wrapper function for command vkGetPhysicalDeviceToolProperties, see
|
|
|
19307 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html
|
|
|
19308 template <
|
|
|
19309 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
|
|
|
19310 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19311 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
|
|
|
19312 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19313 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
|
|
|
19314 getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
|
|
|
19315 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19317
|
|
|
19318 //=== VK_KHR_surface ===
|
|
|
19319
|
|
|
19320 // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see
|
|
|
19321 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html
|
|
|
19322 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19323 VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex,
|
|
|
19324 SurfaceKHR surface,
|
|
|
19325 Bool32 * pSupported,
|
|
|
19326 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19328 // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see
|
|
|
19329 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html
|
|
|
19330 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19331 VULKAN_HPP_NODISCARD typename ResultValueType<Bool32>::type
|
|
|
19332 getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19334
|
|
|
19335 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see
|
|
|
19336 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html
|
|
|
19337 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19338 VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( SurfaceKHR surface,
|
|
|
19339 SurfaceCapabilitiesKHR * pSurfaceCapabilities,
|
|
|
19340 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19342 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see
|
|
|
19343 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html
|
|
|
19344 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19345 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceCapabilitiesKHR>::type
|
|
|
19346 getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19348
|
|
|
19349 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
|
|
|
19350 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
|
|
|
19351 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19352 VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( SurfaceKHR surface,
|
|
|
19353 uint32_t * pSurfaceFormatCount,
|
|
|
19354 SurfaceFormatKHR * pSurfaceFormats,
|
|
|
19355 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19356 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19357 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
|
|
|
19358 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
|
|
|
19359 template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
|
|
|
19360 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19361 typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, SurfaceFormatKHR>::value, int>::type = 0,
|
|
|
19362 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19363 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
|
|
|
19364 getSurfaceFormatsKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19365 // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see
|
|
|
19366 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html
|
|
|
19367 template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
|
|
|
19368 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19369 typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, SurfaceFormatKHR>::value, int>::type = 0,
|
|
|
19370 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19371 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR(
|
|
|
19372 SurfaceKHR surface, SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19373 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19374
|
|
|
19375 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
|
|
|
19376 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
|
|
|
19377 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19378 VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( SurfaceKHR surface,
|
|
|
19379 uint32_t * pPresentModeCount,
|
|
|
19380 PresentModeKHR * pPresentModes,
|
|
|
19381 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19383 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
|
|
|
19384 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
|
|
|
19385 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
|
|
|
19386 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19387 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
|
|
|
19388 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19389 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
|
|
|
19390 getSurfacePresentModesKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19391 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see
|
|
|
19392 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html
|
|
|
19393 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
|
|
|
19394 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19395 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
|
|
|
19396 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19397 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR(
|
|
|
19398 SurfaceKHR surface, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19399 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19400
|
|
|
19401 //=== VK_KHR_swapchain ===
|
|
|
19402
|
|
|
19403 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
|
|
|
19404 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
|
|
|
19405 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19406 VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( SurfaceKHR surface,
|
|
|
19407 uint32_t * pRectCount,
|
|
|
19408 Rect2D * pRects,
|
|
|
19409 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19411 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
|
|
|
19412 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
|
|
|
19413 template <typename Rect2DAllocator = std::allocator<Rect2D>,
|
|
|
19414 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19415 typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, Rect2D>::value, int>::type = 0,
|
|
|
19416 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19417 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
|
|
|
19418 getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19419 // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see
|
|
|
19420 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html
|
|
|
19421 template <typename Rect2DAllocator = std::allocator<Rect2D>,
|
|
|
19422 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19423 typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, Rect2D>::value, int>::type = 0,
|
|
|
19424 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19425 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
|
|
|
19426 getPresentRectanglesKHR( SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19427 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19428
|
|
|
19429 //=== VK_KHR_display ===
|
|
|
19430
|
|
|
19431 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
|
|
|
19432 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
|
|
|
19433 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19434 VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount,
|
|
|
19435 DisplayPropertiesKHR * pProperties,
|
|
|
19436 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19438 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
|
|
|
19439 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
|
|
|
19440 template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
|
|
|
19441 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19442 typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, DisplayPropertiesKHR>::value, int>::type = 0,
|
|
|
19443 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19444 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
|
|
|
19445 getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19446 // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see
|
|
|
19447 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html
|
|
|
19448 template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
|
|
|
19449 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19450 typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, DisplayPropertiesKHR>::value, int>::type = 0,
|
|
|
19451 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19452 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
|
|
|
19453 getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
|
|
|
19454 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19456
|
|
|
19457 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
|
|
|
19458 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
|
|
|
19459 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19460 VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount,
|
|
|
19461 DisplayPlanePropertiesKHR * pProperties,
|
|
|
19462 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19464 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
|
|
|
19465 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
|
|
|
19466 template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
|
|
|
19467 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19468 typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0,
|
|
|
19469 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19470 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
|
|
|
19471 getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19472 // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see
|
|
|
19473 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html
|
|
|
19474 template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
|
|
|
19475 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19476 typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0,
|
|
|
19477 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19478 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
|
|
|
19479 getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
|
|
|
19480 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19481 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19482
|
|
|
19483 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
|
|
|
19484 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
|
|
|
19485 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19486 VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex,
|
|
|
19487 uint32_t * pDisplayCount,
|
|
|
19488 DisplayKHR * pDisplays,
|
|
|
19489 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19491 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
|
|
|
19492 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
|
|
|
19493 template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
|
|
|
19494 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19495 typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, DisplayKHR>::value, int>::type = 0,
|
|
|
19496 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19497 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
|
|
|
19498 getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19499 // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see
|
|
|
19500 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html
|
|
|
19501 template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
|
|
|
19502 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19503 typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, DisplayKHR>::value, int>::type = 0,
|
|
|
19504 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19505 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR(
|
|
|
19506 uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19507 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19508
|
|
|
19509 // wrapper function for command vkGetDisplayModePropertiesKHR, see
|
|
|
19510 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
|
|
|
19511 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19512 VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( DisplayKHR display,
|
|
|
19513 uint32_t * pPropertyCount,
|
|
|
19514 DisplayModePropertiesKHR * pProperties,
|
|
|
19515 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19516 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19517 // wrapper function for command vkGetDisplayModePropertiesKHR, see
|
|
|
19518 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
|
|
|
19519 template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
|
|
|
19520 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19521 typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, DisplayModePropertiesKHR>::value, int>::type = 0,
|
|
|
19522 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19523 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
|
|
|
19524 getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19525 // wrapper function for command vkGetDisplayModePropertiesKHR, see
|
|
|
19526 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html
|
|
|
19527 template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
|
|
|
19528 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19529 typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, DisplayModePropertiesKHR>::value, int>::type = 0,
|
|
|
19530 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19531 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
|
|
|
19532 getDisplayModePropertiesKHR( DisplayKHR display,
|
|
|
19533 DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
|
|
|
19534 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19535 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19536
|
|
|
19537 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
|
|
|
19538 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19539 VULKAN_HPP_NODISCARD Result createDisplayModeKHR( DisplayKHR display,
|
|
|
19540 const DisplayModeCreateInfoKHR * pCreateInfo,
|
|
|
19541 const AllocationCallbacks * pAllocator,
|
|
|
19542 DisplayModeKHR * pMode,
|
|
|
19543 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19545 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
|
|
|
19546 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19547 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayModeKHR>::type
|
|
|
19548 createDisplayModeKHR( DisplayKHR display,
|
|
|
19549 const DisplayModeCreateInfoKHR & createInfo,
|
|
|
19550 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
19551 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19552 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
19553 // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html
|
|
|
19554 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19555 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayModeKHR, Dispatch>>::type
|
|
|
19556 createDisplayModeKHRUnique( DisplayKHR display,
|
|
|
19557 const DisplayModeCreateInfoKHR & createInfo,
|
|
|
19558 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
19559 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19560 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
19561 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19562
|
|
|
19563 // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see
|
|
|
19564 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html
|
|
|
19565 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19566 VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode,
|
|
|
19567 uint32_t planeIndex,
|
|
|
19568 DisplayPlaneCapabilitiesKHR * pCapabilities,
|
|
|
19569 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19570 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19571 // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see
|
|
|
19572 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html
|
|
|
19573 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19574 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayPlaneCapabilitiesKHR>::type
|
|
|
19575 getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19576 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19577
|
|
|
19578 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
19579 //=== VK_KHR_xlib_surface ===
|
|
|
19580
|
|
|
19581 // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see
|
|
|
19582 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html
|
|
|
19583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19584 Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
|
|
|
19585 Display * dpy,
|
|
|
19586 VisualID visualID,
|
|
|
19587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19588 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19589 // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see
|
|
|
19590 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html
|
|
|
19591 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19592 Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
|
|
|
19593 Display & dpy,
|
|
|
19594 VisualID visualID,
|
|
|
19595 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19596 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19597 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
19598
|
|
|
19599 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
19600 //=== VK_KHR_xcb_surface ===
|
|
|
19601
|
|
|
19602 // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see
|
|
|
19603 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html
|
|
|
19604 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19605 Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
|
|
|
19606 xcb_connection_t * connection,
|
|
|
19607 xcb_visualid_t visual_id,
|
|
|
19608 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19609 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19610 // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see
|
|
|
19611 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html
|
|
|
19612 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19613 Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
|
|
|
19614 xcb_connection_t & connection,
|
|
|
19615 xcb_visualid_t visual_id,
|
|
|
19616 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19617 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19618 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
19619
|
|
|
19620 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
19621 //=== VK_KHR_wayland_surface ===
|
|
|
19622
|
|
|
19623 // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see
|
|
|
19624 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html
|
|
|
19625 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19626 Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
|
|
|
19627 struct wl_display * display,
|
|
|
19628 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19629 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19630 // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see
|
|
|
19631 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html
|
|
|
19632 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19633 Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
|
|
|
19634 struct wl_display & display,
|
|
|
19635 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19636 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19637 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
19638
|
|
|
19639 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
19640 //=== VK_KHR_win32_surface ===
|
|
|
19641
|
|
|
19642 // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see
|
|
|
19643 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html
|
|
|
19644 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19645 Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19646 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
19647
|
|
|
19648 //=== VK_KHR_video_queue ===
|
|
|
19649
|
|
|
19650 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
|
|
|
19651 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
|
|
|
19652 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19653 VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile,
|
|
|
19654 VideoCapabilitiesKHR * pCapabilities,
|
|
|
19655 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19657 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
|
|
|
19658 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
|
|
|
19659 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19660 VULKAN_HPP_NODISCARD typename ResultValueType<VideoCapabilitiesKHR>::type
|
|
|
19661 getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19662 // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see
|
|
|
19663 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html
|
|
|
19664 template <typename X,
|
|
|
19665 typename Y,
|
|
|
19666 typename... Z,
|
|
|
19667 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19668 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19669 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
19670 getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19672
|
|
|
19673 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
|
|
|
19674 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
|
|
|
19675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19676 VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
|
|
|
19677 uint32_t * pVideoFormatPropertyCount,
|
|
|
19678 VideoFormatPropertiesKHR * pVideoFormatProperties,
|
|
|
19679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19681 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
|
|
|
19682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
|
|
|
19683 template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
|
|
|
19684 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19685 typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0,
|
|
|
19686 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19687 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
|
|
|
19688 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
|
|
|
19689 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19690 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
|
|
|
19691 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
|
|
|
19692 template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
|
|
|
19693 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19694 typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0,
|
|
|
19695 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19696 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
|
|
|
19697 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
|
|
|
19698 VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
|
|
|
19699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19700 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
|
|
|
19701 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
|
|
|
19702 template <typename StructureChain,
|
|
|
19703 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
19704 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19705 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
19706 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19707 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
|
|
|
19708 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
|
|
|
19709 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19710 // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see
|
|
|
19711 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html
|
|
|
19712 template <typename StructureChain,
|
|
|
19713 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
19714 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19715 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
19716 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19717 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
|
|
|
19718 getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
|
|
|
19719 StructureChainAllocator & structureChainAllocator,
|
|
|
19720 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19721 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19722
|
|
|
19723 //=== VK_NV_external_memory_capabilities ===
|
|
|
19724
|
|
|
19725 // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see
|
|
|
19726 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html
|
|
|
19727 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19728 VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( Format format,
|
|
|
19729 ImageType type,
|
|
|
19730 ImageTiling tiling,
|
|
|
19731 ImageUsageFlags usage,
|
|
|
19732 ImageCreateFlags flags,
|
|
|
19733 ExternalMemoryHandleTypeFlagsNV externalHandleType,
|
|
|
19734 ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
|
|
|
19735 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19736 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19737 // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see
|
|
|
19738 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html
|
|
|
19739 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19740 VULKAN_HPP_NODISCARD typename ResultValueType<ExternalImageFormatPropertiesNV>::type
|
|
|
19741 getExternalImageFormatPropertiesNV( Format format,
|
|
|
19742 ImageType type,
|
|
|
19743 ImageTiling tiling,
|
|
|
19744 ImageUsageFlags usage,
|
|
|
19745 ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
19746 ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
19747 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19748 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19749
|
|
|
19750 //=== VK_KHR_get_physical_device_properties2 ===
|
|
|
19751
|
|
|
19752 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
|
|
|
19753 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
|
|
|
19754 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19755 void getFeatures2KHR( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19756 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19757 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
|
|
|
19758 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
|
|
|
19759 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19760 VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19761 // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see
|
|
|
19762 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html
|
|
|
19763 template <typename X,
|
|
|
19764 typename Y,
|
|
|
19765 typename... Z,
|
|
|
19766 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19767 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19768 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19769 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19770
|
|
|
19771 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
|
|
|
19772 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
|
|
|
19773 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19774 void getProperties2KHR( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19776 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
|
|
|
19777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
|
|
|
19778 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19779 VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19780 // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see
|
|
|
19781 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html
|
|
|
19782 template <typename X,
|
|
|
19783 typename Y,
|
|
|
19784 typename... Z,
|
|
|
19785 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19786 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19787 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19788 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19789
|
|
|
19790 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
|
|
|
19791 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
|
|
|
19792 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19793 void getFormatProperties2KHR( Format format,
|
|
|
19794 FormatProperties2 * pFormatProperties,
|
|
|
19795 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19797 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
|
|
|
19798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
|
|
|
19799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19800 VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2KHR( Format format,
|
|
|
19801 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19802 // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see
|
|
|
19803 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html
|
|
|
19804 template <typename X,
|
|
|
19805 typename Y,
|
|
|
19806 typename... Z,
|
|
|
19807 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19808 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19809 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
19810 getFormatProperties2KHR( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19811 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19812
|
|
|
19813 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
|
|
|
19814 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
|
|
|
19815 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19816 VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
|
|
|
19817 ImageFormatProperties2 * pImageFormatProperties,
|
|
|
19818 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19820 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
|
|
|
19821 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
|
|
|
19822 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19823 VULKAN_HPP_NODISCARD typename ResultValueType<ImageFormatProperties2>::type
|
|
|
19824 getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19825 // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see
|
|
|
19826 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html
|
|
|
19827 template <typename X,
|
|
|
19828 typename Y,
|
|
|
19829 typename... Z,
|
|
|
19830 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19831 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19832 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
19833 getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19835
|
|
|
19836 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
|
|
|
19837 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
|
|
|
19838 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19839 void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
|
|
|
19840 QueueFamilyProperties2 * pQueueFamilyProperties,
|
|
|
19841 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19843 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
|
|
|
19844 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
|
|
|
19845 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
|
|
|
19846 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19847 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
|
|
|
19848 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19849 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
|
|
|
19850 getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19851 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
|
|
|
19852 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
|
|
|
19853 template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
|
|
|
19854 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19855 typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, QueueFamilyProperties2>::value, int>::type = 0,
|
|
|
19856 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19857 VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
|
|
|
19858 getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
|
|
|
19859 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19860 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
|
|
|
19861 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
|
|
|
19862 template <typename StructureChain,
|
|
|
19863 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
19864 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19865 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
19866 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19867 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
|
|
|
19868 getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19869 // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see
|
|
|
19870 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html
|
|
|
19871 template <typename StructureChain,
|
|
|
19872 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
19873 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19874 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
19875 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19876 VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
|
|
|
19877 getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19878 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19879
|
|
|
19880 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
|
|
|
19881 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
|
|
|
19882 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19883 void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2 * pMemoryProperties,
|
|
|
19884 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19885 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19886 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
|
|
|
19887 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
|
|
|
19888 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19889 VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2
|
|
|
19890 getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19891 // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see
|
|
|
19892 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html
|
|
|
19893 template <typename X,
|
|
|
19894 typename Y,
|
|
|
19895 typename... Z,
|
|
|
19896 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19897 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19898 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
|
|
|
19899 getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19901
|
|
|
19902 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
|
|
|
19903 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
|
|
|
19904 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19905 void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
|
|
|
19906 uint32_t * pPropertyCount,
|
|
|
19907 SparseImageFormatProperties2 * pProperties,
|
|
|
19908 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19910 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
|
|
|
19911 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
|
|
|
19912 template <
|
|
|
19913 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
|
|
|
19914 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19915 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
|
|
|
19916 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19917 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
|
|
|
19918 getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
|
|
|
19919 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19920 // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see
|
|
|
19921 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html
|
|
|
19922 template <
|
|
|
19923 typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
|
|
|
19924 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
19925 typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, SparseImageFormatProperties2>::value, int>::type = 0,
|
|
|
19926 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19927 VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
|
|
|
19928 getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
|
|
|
19929 SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
|
|
|
19930 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19932
|
|
|
19933 //=== VK_KHR_external_memory_capabilities ===
|
|
|
19934
|
|
|
19935 // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see
|
|
|
19936 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html
|
|
|
19937 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19938 void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
|
|
|
19939 ExternalBufferProperties * pExternalBufferProperties,
|
|
|
19940 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19941 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19942 // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see
|
|
|
19943 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html
|
|
|
19944 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19945 VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferPropertiesKHR(
|
|
|
19946 const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19947 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19948
|
|
|
19949 //=== VK_KHR_external_semaphore_capabilities ===
|
|
|
19950
|
|
|
19951 // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see
|
|
|
19952 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html
|
|
|
19953 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19954 void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
|
|
|
19955 ExternalSemaphoreProperties * pExternalSemaphoreProperties,
|
|
|
19956 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19957 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19958 // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see
|
|
|
19959 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html
|
|
|
19960 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19961 VULKAN_HPP_NODISCARD ExternalSemaphoreProperties
|
|
|
19962 getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
|
|
|
19963 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19964 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19965
|
|
|
19966 //=== VK_EXT_direct_mode_display ===
|
|
|
19967
|
|
|
19968 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19969 // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
|
|
|
19970 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19971 VULKAN_HPP_NODISCARD Result releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19972 #else
|
|
|
19973 // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
|
|
|
19974 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19975 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
19976 releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19977 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
19978
|
|
|
19979 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
|
|
|
19980 //=== VK_EXT_acquire_xlib_display ===
|
|
|
19981
|
|
|
19982 // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html
|
|
|
19983 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19984 VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy,
|
|
|
19985 DisplayKHR display,
|
|
|
19986 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
19987 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19988 // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html
|
|
|
19989 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19990 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
19991 acquireXlibDisplayEXT( Display & dpy, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
19992 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
19993
|
|
|
19994 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
|
|
|
19995 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
19996 VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy,
|
|
|
19997 RROutput rrOutput,
|
|
|
19998 DisplayKHR * pDisplay,
|
|
|
19999 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20000 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20001 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
|
|
|
20002 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20003 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayKHR>::type
|
|
|
20004 getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20005 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
20006 // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html
|
|
|
20007 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20008 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
|
|
|
20009 getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20010 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
20011 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20012 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
|
|
|
20013
|
|
|
20014 //=== VK_EXT_display_surface_counter ===
|
|
|
20015
|
|
|
20016 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see
|
|
|
20017 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html
|
|
|
20018 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20019 VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( SurfaceKHR surface,
|
|
|
20020 SurfaceCapabilities2EXT * pSurfaceCapabilities,
|
|
|
20021 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20022 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20023 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see
|
|
|
20024 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html
|
|
|
20025 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20026 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceCapabilities2EXT>::type
|
|
|
20027 getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20029
|
|
|
20030 //=== VK_KHR_external_fence_capabilities ===
|
|
|
20031
|
|
|
20032 // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see
|
|
|
20033 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html
|
|
|
20034 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20035 void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
|
|
|
20036 ExternalFenceProperties * pExternalFenceProperties,
|
|
|
20037 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20039 // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see
|
|
|
20040 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html
|
|
|
20041 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20042 VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFencePropertiesKHR(
|
|
|
20043 const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20044 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20045
|
|
|
20046 //=== VK_KHR_performance_query ===
|
|
|
20047
|
|
|
20048 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
|
|
|
20049 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
|
|
|
20050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20051 VULKAN_HPP_NODISCARD Result
|
|
|
20052 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
|
|
|
20053 uint32_t * pCounterCount,
|
|
|
20054 PerformanceCounterKHR * pCounters,
|
|
|
20055 PerformanceCounterDescriptionKHR * pCounterDescriptions,
|
|
|
20056 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20057 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20058 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
|
|
|
20059 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
|
|
|
20060 template <typename PerformanceCounterKHRAllocator = std::allocator<PerformanceCounterKHR>,
|
|
|
20061 typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
|
|
|
20062 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20063 typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, PerformanceCounterKHR>::value &&
|
|
|
20064 std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, PerformanceCounterDescriptionKHR>::value,
|
|
|
20065 int>::type = 0,
|
|
|
20066 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20067 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
|
|
|
20068 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
|
|
|
20069 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20070 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see
|
|
|
20071 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html
|
|
|
20072 template <typename PerformanceCounterKHRAllocator = std::allocator<PerformanceCounterKHR>,
|
|
|
20073 typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
|
|
|
20074 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20075 typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, PerformanceCounterKHR>::value &&
|
|
|
20076 std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, PerformanceCounterDescriptionKHR>::value,
|
|
|
20077 int>::type = 0,
|
|
|
20078 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20079 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
|
|
|
20080 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
|
|
|
20081 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
|
|
|
20082 PerformanceCounterKHRAllocator & performanceCounterKHRAllocator,
|
|
|
20083 PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
|
|
|
20084 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20086
|
|
|
20087 // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see
|
|
|
20088 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html
|
|
|
20089 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20090 void getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
|
|
|
20091 uint32_t * pNumPasses,
|
|
|
20092 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20093 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20094 // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see
|
|
|
20095 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html
|
|
|
20096 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20097 VULKAN_HPP_NODISCARD uint32_t
|
|
|
20098 getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
|
|
|
20099 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20101
|
|
|
20102 //=== VK_KHR_get_surface_capabilities2 ===
|
|
|
20103
|
|
|
20104 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
|
|
|
20105 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
|
|
|
20106 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20107 VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
20108 SurfaceCapabilities2KHR * pSurfaceCapabilities,
|
|
|
20109 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20111 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
|
|
|
20112 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
|
|
|
20113 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20114 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceCapabilities2KHR>::type
|
|
|
20115 getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20116 // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see
|
|
|
20117 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html
|
|
|
20118 template <typename X,
|
|
|
20119 typename Y,
|
|
|
20120 typename... Z,
|
|
|
20121 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20122 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20123 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
20124 getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20126
|
|
|
20127 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
|
|
|
20128 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
|
|
|
20129 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20130 VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
20131 uint32_t * pSurfaceFormatCount,
|
|
|
20132 SurfaceFormat2KHR * pSurfaceFormats,
|
|
|
20133 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20134 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20135 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
|
|
|
20136 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
|
|
|
20137 template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
|
|
|
20138 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20139 typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, SurfaceFormat2KHR>::value, int>::type = 0,
|
|
|
20140 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20141 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
|
|
|
20142 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20143 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
|
|
|
20144 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
|
|
|
20145 template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
|
|
|
20146 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20147 typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, SurfaceFormat2KHR>::value, int>::type = 0,
|
|
|
20148 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20149 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
|
|
|
20150 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
|
|
|
20151 SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator,
|
|
|
20152 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20153 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
|
|
|
20154 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
|
|
|
20155 template <typename StructureChain,
|
|
|
20156 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
20157 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20158 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
20159 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20160 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
|
|
|
20161 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20162 // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see
|
|
|
20163 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html
|
|
|
20164 template <typename StructureChain,
|
|
|
20165 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
20166 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20167 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
20168 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20169 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
|
|
|
20170 getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
|
|
|
20171 StructureChainAllocator & structureChainAllocator,
|
|
|
20172 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20174
|
|
|
20175 //=== VK_KHR_get_display_properties2 ===
|
|
|
20176
|
|
|
20177 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
|
|
|
20178 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
|
|
|
20179 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20180 VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount,
|
|
|
20181 DisplayProperties2KHR * pProperties,
|
|
|
20182 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20184 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
|
|
|
20185 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
|
|
|
20186 template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
|
|
|
20187 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20188 typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, DisplayProperties2KHR>::value, int>::type = 0,
|
|
|
20189 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20190 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
|
|
|
20191 getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20192 // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see
|
|
|
20193 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html
|
|
|
20194 template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
|
|
|
20195 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20196 typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, DisplayProperties2KHR>::value, int>::type = 0,
|
|
|
20197 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20198 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
|
|
|
20199 getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
|
|
|
20200 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20201 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20202
|
|
|
20203 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
|
|
|
20204 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
|
|
|
20205 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20206 VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount,
|
|
|
20207 DisplayPlaneProperties2KHR * pProperties,
|
|
|
20208 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20209 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20210 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
|
|
|
20211 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
|
|
|
20212 template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
|
|
|
20213 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20214 typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0,
|
|
|
20215 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20216 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
|
|
|
20217 getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20218 // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see
|
|
|
20219 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html
|
|
|
20220 template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
|
|
|
20221 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20222 typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0,
|
|
|
20223 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20224 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
|
|
|
20225 getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
|
|
|
20226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20228
|
|
|
20229 // wrapper function for command vkGetDisplayModeProperties2KHR, see
|
|
|
20230 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
|
|
|
20231 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20232 VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( DisplayKHR display,
|
|
|
20233 uint32_t * pPropertyCount,
|
|
|
20234 DisplayModeProperties2KHR * pProperties,
|
|
|
20235 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20237 // wrapper function for command vkGetDisplayModeProperties2KHR, see
|
|
|
20238 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
|
|
|
20239 template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
|
|
|
20240 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20241 typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, DisplayModeProperties2KHR>::value, int>::type = 0,
|
|
|
20242 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20243 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
|
|
|
20244 getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20245 // wrapper function for command vkGetDisplayModeProperties2KHR, see
|
|
|
20246 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
|
|
|
20247 template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
|
|
|
20248 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20249 typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, DisplayModeProperties2KHR>::value, int>::type = 0,
|
|
|
20250 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20251 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
|
|
|
20252 getDisplayModeProperties2KHR( DisplayKHR display,
|
|
|
20253 DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
|
|
|
20254 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20255 // wrapper function for command vkGetDisplayModeProperties2KHR, see
|
|
|
20256 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
|
|
|
20257 template <typename StructureChain,
|
|
|
20258 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
20259 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20260 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
20261 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20262 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
|
|
|
20263 getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20264 // wrapper function for command vkGetDisplayModeProperties2KHR, see
|
|
|
20265 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html
|
|
|
20266 template <typename StructureChain,
|
|
|
20267 typename StructureChainAllocator = std::allocator<StructureChain>,
|
|
|
20268 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20269 typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0,
|
|
|
20270 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20271 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getDisplayModeProperties2KHR(
|
|
|
20272 DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20274
|
|
|
20275 // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see
|
|
|
20276 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html
|
|
|
20277 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20278 VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR * pDisplayPlaneInfo,
|
|
|
20279 DisplayPlaneCapabilities2KHR * pCapabilities,
|
|
|
20280 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20282 // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see
|
|
|
20283 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html
|
|
|
20284 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20285 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayPlaneCapabilities2KHR>::type
|
|
|
20286 getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20288
|
|
|
20289 //=== VK_EXT_sample_locations ===
|
|
|
20290
|
|
|
20291 // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see
|
|
|
20292 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html
|
|
|
20293 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20294 void getMultisamplePropertiesEXT( SampleCountFlagBits samples,
|
|
|
20295 MultisamplePropertiesEXT * pMultisampleProperties,
|
|
|
20296 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20298 // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see
|
|
|
20299 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html
|
|
|
20300 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20301 VULKAN_HPP_NODISCARD MultisamplePropertiesEXT
|
|
|
20302 getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20304
|
|
|
20305 //=== VK_EXT_calibrated_timestamps ===
|
|
|
20306
|
|
|
20307 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
|
|
|
20308 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
|
|
|
20309 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20310 VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount,
|
|
|
20311 TimeDomainKHR * pTimeDomains,
|
|
|
20312 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20314 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
|
|
|
20315 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
|
|
|
20316 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
|
|
|
20317 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20318 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
|
|
|
20319 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20320 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
|
|
20321 getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20322 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see
|
|
|
20323 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html
|
|
|
20324 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
|
|
|
20325 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20326 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
|
|
|
20327 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20328 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
|
|
20329 getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20330 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20331
|
|
|
20332 //=== VK_KHR_fragment_shading_rate ===
|
|
|
20333
|
|
|
20334 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
|
|
|
20335 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
|
|
|
20336 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20337 VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount,
|
|
|
20338 PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
|
|
|
20339 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20340 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20341 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
|
|
|
20342 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
|
|
|
20343 template <
|
|
|
20344 typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
|
|
|
20345 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20346 typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
|
|
|
20347 int>::type = 0,
|
|
|
20348 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20349 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
|
|
|
20350 getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20351 // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see
|
|
|
20352 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html
|
|
|
20353 template <
|
|
|
20354 typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
|
|
|
20355 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20356 typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
|
|
|
20357 int>::type = 0,
|
|
|
20358 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20359 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
|
|
|
20360 getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
|
|
|
20361 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20363
|
|
|
20364 //=== VK_EXT_tooling_info ===
|
|
|
20365
|
|
|
20366 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
|
|
|
20367 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
|
|
|
20368 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20369 VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount,
|
|
|
20370 PhysicalDeviceToolProperties * pToolProperties,
|
|
|
20371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20372 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20373 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
|
|
|
20374 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
|
|
|
20375 template <
|
|
|
20376 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
|
|
|
20377 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20378 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
|
|
|
20379 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20380 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
|
|
|
20381 getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20382 // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see
|
|
|
20383 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html
|
|
|
20384 template <
|
|
|
20385 typename PhysicalDeviceToolPropertiesAllocator = std::allocator<PhysicalDeviceToolProperties>,
|
|
|
20386 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20387 typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0,
|
|
|
20388 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20389 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
|
|
|
20390 getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
|
|
|
20391 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20392 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20393
|
|
|
20394 //=== VK_NV_cooperative_matrix ===
|
|
|
20395
|
|
|
20396 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
|
|
|
20397 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
|
|
|
20398 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20399 VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount,
|
|
|
20400 CooperativeMatrixPropertiesNV * pProperties,
|
|
|
20401 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20403 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
|
|
|
20404 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
|
|
|
20405 template <
|
|
|
20406 typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
|
|
|
20407 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20408 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0,
|
|
|
20409 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20410 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
|
|
|
20411 getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20412 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see
|
|
|
20413 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html
|
|
|
20414 template <
|
|
|
20415 typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
|
|
|
20416 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20417 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0,
|
|
|
20418 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20419 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
|
|
|
20420 getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
|
|
|
20421 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20422 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20423
|
|
|
20424 //=== VK_NV_coverage_reduction_mode ===
|
|
|
20425
|
|
|
20426 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
|
|
|
20427 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
|
|
|
20428 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20429 VULKAN_HPP_NODISCARD Result
|
|
|
20430 getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount,
|
|
|
20431 FramebufferMixedSamplesCombinationNV * pCombinations,
|
|
|
20432 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20433 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20434 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
|
|
|
20435 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
|
|
|
20436 template <
|
|
|
20437 typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
|
|
|
20438 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20439 typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, FramebufferMixedSamplesCombinationNV>::value,
|
|
|
20440 int>::type = 0,
|
|
|
20441 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20442 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
|
|
|
20443 getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20444 // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see
|
|
|
20445 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html
|
|
|
20446 template <
|
|
|
20447 typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
|
|
|
20448 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20449 typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, FramebufferMixedSamplesCombinationNV>::value,
|
|
|
20450 int>::type = 0,
|
|
|
20451 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20452 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
|
|
|
20453 getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
|
|
|
20454 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20456
|
|
|
20457 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20458 //=== VK_EXT_full_screen_exclusive ===
|
|
|
20459
|
|
|
20460 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
|
|
|
20461 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
|
|
|
20462 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20463 VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
20464 uint32_t * pPresentModeCount,
|
|
|
20465 PresentModeKHR * pPresentModes,
|
|
|
20466 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20467 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20468 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
|
|
|
20469 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
|
|
|
20470 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
|
|
|
20471 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20472 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
|
|
|
20473 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20474 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
|
|
|
20475 getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20476 // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see
|
|
|
20477 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html
|
|
|
20478 template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
|
|
|
20479 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20480 typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, PresentModeKHR>::value, int>::type = 0,
|
|
|
20481 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20482 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
|
|
|
20483 getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
|
|
|
20484 PresentModeKHRAllocator & presentModeKHRAllocator,
|
|
|
20485 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20486 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20487 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20488
|
|
|
20489 //=== VK_EXT_acquire_drm_display ===
|
|
|
20490
|
|
|
20491 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20492 // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
|
|
|
20493 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20494 VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd,
|
|
|
20495 DisplayKHR display,
|
|
|
20496 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20497 #else
|
|
|
20498 // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
|
|
|
20499 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20500 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
20501 acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20502 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
20503
|
|
|
20504 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
|
|
|
20505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20506 VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t drmFd,
|
|
|
20507 uint32_t connectorId,
|
|
|
20508 DisplayKHR * display,
|
|
|
20509 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20511 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
|
|
|
20512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20513 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayKHR>::type
|
|
|
20514 getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20515 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
20516 // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html
|
|
|
20517 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20518 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
|
|
|
20519 getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20520 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
20521 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20522
|
|
|
20523 //=== VK_KHR_video_encode_queue ===
|
|
|
20524
|
|
|
20525 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
|
|
|
20526 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
|
|
|
20527 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20528 VULKAN_HPP_NODISCARD Result
|
|
|
20529 getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
|
|
|
20530 VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties,
|
|
|
20531 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20533 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
|
|
|
20534 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
|
|
|
20535 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20536 VULKAN_HPP_NODISCARD typename ResultValueType<VideoEncodeQualityLevelPropertiesKHR>::type
|
|
|
20537 getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
|
|
|
20538 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20539 // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see
|
|
|
20540 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html
|
|
|
20541 template <typename X,
|
|
|
20542 typename Y,
|
|
|
20543 typename... Z,
|
|
|
20544 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20545 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20546 VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type
|
|
|
20547 getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
|
|
|
20548 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20549 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20550
|
|
|
20551 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20552 //=== VK_NV_acquire_winrt_display ===
|
|
|
20553
|
|
|
20554 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20555 // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html
|
|
|
20556 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20557 VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( DisplayKHR display,
|
|
|
20558 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20559 # else
|
|
|
20560 // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html
|
|
|
20561 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20562 VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
|
|
|
20563 acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20564 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
|
|
20565
|
|
|
20566 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
|
|
|
20567 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20568 VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId,
|
|
|
20569 DisplayKHR * pDisplay,
|
|
|
20570 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20571 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20572 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
|
|
|
20573 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20574 VULKAN_HPP_NODISCARD typename ResultValueType<DisplayKHR>::type getWinrtDisplayNV( uint32_t deviceRelativeId,
|
|
|
20575 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20576 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
20577 // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html
|
|
|
20578 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20579 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DisplayKHR, Dispatch>>::type
|
|
|
20580 getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20581 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
20582 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20583 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20584
|
|
|
20585 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
20586 //=== VK_EXT_directfb_surface ===
|
|
|
20587
|
|
|
20588 // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see
|
|
|
20589 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html
|
|
|
20590 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20591 Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
|
|
|
20592 IDirectFB * dfb,
|
|
|
20593 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20594 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20595 // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see
|
|
|
20596 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html
|
|
|
20597 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20598 Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
|
|
|
20599 IDirectFB & dfb,
|
|
|
20600 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20601 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20602 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
20603
|
|
|
20604 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
20605 //=== VK_QNX_screen_surface ===
|
|
|
20606
|
|
|
20607 // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see
|
|
|
20608 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html
|
|
|
20609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20610 Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
|
|
|
20611 struct _screen_window * window,
|
|
|
20612 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20613 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20614 // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see
|
|
|
20615 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html
|
|
|
20616 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20617 Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
|
|
|
20618 struct _screen_window & window,
|
|
|
20619 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20620 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20621 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
20622
|
|
|
20623 //=== VK_ARM_tensors ===
|
|
|
20624
|
|
|
20625 // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see
|
|
|
20626 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html
|
|
|
20627 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20628 void getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo,
|
|
|
20629 ExternalTensorPropertiesARM * pExternalTensorProperties,
|
|
|
20630 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20631 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20632 // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see
|
|
|
20633 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html
|
|
|
20634 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20635 VULKAN_HPP_NODISCARD ExternalTensorPropertiesARM getExternalTensorPropertiesARM(
|
|
|
20636 const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20638
|
|
|
20639 //=== VK_NV_optical_flow ===
|
|
|
20640
|
|
|
20641 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
|
|
|
20642 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
|
|
|
20643 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20644 VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
|
|
|
20645 uint32_t * pFormatCount,
|
|
|
20646 OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,
|
|
|
20647 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20648 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20649 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
|
|
|
20650 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
|
|
|
20651 template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<OpticalFlowImageFormatPropertiesNV>,
|
|
|
20652 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20653 typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, OpticalFlowImageFormatPropertiesNV>::value,
|
|
|
20654 int>::type = 0,
|
|
|
20655 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20656 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
|
|
|
20657 getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
|
|
|
20658 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20659 // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see
|
|
|
20660 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html
|
|
|
20661 template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<OpticalFlowImageFormatPropertiesNV>,
|
|
|
20662 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20663 typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, OpticalFlowImageFormatPropertiesNV>::value,
|
|
|
20664 int>::type = 0,
|
|
|
20665 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20666 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
|
|
|
20667 getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
|
|
|
20668 OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator,
|
|
|
20669 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20671
|
|
|
20672 //=== VK_NV_cooperative_vector ===
|
|
|
20673
|
|
|
20674 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
|
|
|
20675 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
|
|
|
20676 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20677 VULKAN_HPP_NODISCARD Result getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount,
|
|
|
20678 CooperativeVectorPropertiesNV * pProperties,
|
|
|
20679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20681 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
|
|
|
20682 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
|
|
|
20683 template <
|
|
|
20684 typename CooperativeVectorPropertiesNVAllocator = std::allocator<CooperativeVectorPropertiesNV>,
|
|
|
20685 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20686 typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, CooperativeVectorPropertiesNV>::value, int>::type = 0,
|
|
|
20687 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20688 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type
|
|
|
20689 getCooperativeVectorPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20690 // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see
|
|
|
20691 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html
|
|
|
20692 template <
|
|
|
20693 typename CooperativeVectorPropertiesNVAllocator = std::allocator<CooperativeVectorPropertiesNV>,
|
|
|
20694 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20695 typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, CooperativeVectorPropertiesNV>::value, int>::type = 0,
|
|
|
20696 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20697 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type
|
|
|
20698 getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator & cooperativeVectorPropertiesNVAllocator,
|
|
|
20699 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20700 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20701
|
|
|
20702 //=== VK_KHR_cooperative_matrix ===
|
|
|
20703
|
|
|
20704 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
|
|
|
20705 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
|
|
|
20706 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20707 VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount,
|
|
|
20708 CooperativeMatrixPropertiesKHR * pProperties,
|
|
|
20709 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20710 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20711 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
|
|
|
20712 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
|
|
|
20713 template <
|
|
|
20714 typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<CooperativeMatrixPropertiesKHR>,
|
|
|
20715 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20716 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, CooperativeMatrixPropertiesKHR>::value, int>::type = 0,
|
|
|
20717 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20718 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
|
|
|
20719 getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20720 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see
|
|
|
20721 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html
|
|
|
20722 template <
|
|
|
20723 typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<CooperativeMatrixPropertiesKHR>,
|
|
|
20724 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20725 typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, CooperativeMatrixPropertiesKHR>::value, int>::type = 0,
|
|
|
20726 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20727 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
|
|
|
20728 getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
|
|
|
20729 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20731
|
|
|
20732 //=== VK_ARM_data_graph ===
|
|
|
20733
|
|
|
20734 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
|
|
|
20735 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
|
|
|
20736 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20737 VULKAN_HPP_NODISCARD Result getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex,
|
|
|
20738 uint32_t * pQueueFamilyDataGraphPropertyCount,
|
|
|
20739 QueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties,
|
|
|
20740 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20741 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20742 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
|
|
|
20743 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
|
|
|
20744 template <typename QueueFamilyDataGraphPropertiesARMAllocator = std::allocator<QueueFamilyDataGraphPropertiesARM>,
|
|
|
20745 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20746 typename std::enable_if<std::is_same<typename QueueFamilyDataGraphPropertiesARMAllocator::value_type, QueueFamilyDataGraphPropertiesARM>::value,
|
|
|
20747 int>::type = 0,
|
|
|
20748 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20749 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator>>::type
|
|
|
20750 getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20751 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see
|
|
|
20752 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html
|
|
|
20753 template <typename QueueFamilyDataGraphPropertiesARMAllocator = std::allocator<QueueFamilyDataGraphPropertiesARM>,
|
|
|
20754 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20755 typename std::enable_if<std::is_same<typename QueueFamilyDataGraphPropertiesARMAllocator::value_type, QueueFamilyDataGraphPropertiesARM>::value,
|
|
|
20756 int>::type = 0,
|
|
|
20757 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20758 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<QueueFamilyDataGraphPropertiesARM, QueueFamilyDataGraphPropertiesARMAllocator>>::type
|
|
|
20759 getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex,
|
|
|
20760 QueueFamilyDataGraphPropertiesARMAllocator & queueFamilyDataGraphPropertiesARMAllocator,
|
|
|
20761 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20763
|
|
|
20764 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see
|
|
|
20765 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html
|
|
|
20766 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20767 void getQueueFamilyDataGraphProcessingEnginePropertiesARM(
|
|
|
20768 const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo,
|
|
|
20769 QueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties,
|
|
|
20770 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20771 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20772 // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see
|
|
|
20773 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html
|
|
|
20774 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20775 VULKAN_HPP_NODISCARD QueueFamilyDataGraphProcessingEnginePropertiesARM getQueueFamilyDataGraphProcessingEnginePropertiesARM(
|
|
|
20776 const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo,
|
|
|
20777 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20778 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20779
|
|
|
20780 //=== VK_KHR_calibrated_timestamps ===
|
|
|
20781
|
|
|
20782 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
|
|
|
20783 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
|
|
|
20784 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20785 VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount,
|
|
|
20786 TimeDomainKHR * pTimeDomains,
|
|
|
20787 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20788 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20789 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
|
|
|
20790 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
|
|
|
20791 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
|
|
|
20792 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20793 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
|
|
|
20794 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20795 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
|
|
20796 getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20797 // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see
|
|
|
20798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html
|
|
|
20799 template <typename TimeDomainKHRAllocator = std::allocator<TimeDomainKHR>,
|
|
|
20800 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20801 typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, TimeDomainKHR>::value, int>::type = 0,
|
|
|
20802 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20803 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainKHR, TimeDomainKHRAllocator>>::type
|
|
|
20804 getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20805 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20806
|
|
|
20807 //=== VK_NV_cooperative_matrix2 ===
|
|
|
20808
|
|
|
20809 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
|
|
|
20810 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
|
|
|
20811 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20812 VULKAN_HPP_NODISCARD Result
|
|
|
20813 getCooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t * pPropertyCount,
|
|
|
20814 CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties,
|
|
|
20815 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20816 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20817 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
|
|
|
20818 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
|
|
|
20819 template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator = std::allocator<CooperativeMatrixFlexibleDimensionsPropertiesNV>,
|
|
|
20820 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20821 typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type,
|
|
|
20822 CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
|
|
|
20823 int>::type = 0,
|
|
|
20824 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20825 VULKAN_HPP_NODISCARD
|
|
|
20826 typename ResultValueType<std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type
|
|
|
20827 getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20828 // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
|
|
|
20829 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html
|
|
|
20830 template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator = std::allocator<CooperativeMatrixFlexibleDimensionsPropertiesNV>,
|
|
|
20831 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20832 typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type,
|
|
|
20833 CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
|
|
|
20834 int>::type = 0,
|
|
|
20835 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20836 VULKAN_HPP_NODISCARD
|
|
|
20837 typename ResultValueType<std::vector<CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type
|
|
|
20838 getCooperativeMatrixFlexibleDimensionsPropertiesNV(
|
|
|
20839 CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator,
|
|
|
20840 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20842
|
|
|
20843 //=== VK_ARM_performance_counters_by_region ===
|
|
|
20844
|
|
|
20845 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
|
|
|
20846 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
|
|
|
20847 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20848 VULKAN_HPP_NODISCARD Result
|
|
|
20849 enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex,
|
|
|
20850 uint32_t * pCounterCount,
|
|
|
20851 PerformanceCounterARM * pCounters,
|
|
|
20852 PerformanceCounterDescriptionARM * pCounterDescriptions,
|
|
|
20853 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20855 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
|
|
|
20856 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
|
|
|
20857 template <typename PerformanceCounterARMAllocator = std::allocator<PerformanceCounterARM>,
|
|
|
20858 typename PerformanceCounterDescriptionARMAllocator = std::allocator<PerformanceCounterDescriptionARM>,
|
|
|
20859 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20860 typename std::enable_if<std::is_same<typename PerformanceCounterARMAllocator::value_type, PerformanceCounterARM>::value &&
|
|
|
20861 std::is_same<typename PerformanceCounterDescriptionARMAllocator::value_type, PerformanceCounterDescriptionARM>::value,
|
|
|
20862 int>::type = 0,
|
|
|
20863 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20864 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
|
|
|
20865 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>>::type
|
|
|
20866 enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20867 // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see
|
|
|
20868 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html
|
|
|
20869 template <typename PerformanceCounterARMAllocator = std::allocator<PerformanceCounterARM>,
|
|
|
20870 typename PerformanceCounterDescriptionARMAllocator = std::allocator<PerformanceCounterDescriptionARM>,
|
|
|
20871 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20872 typename std::enable_if<std::is_same<typename PerformanceCounterARMAllocator::value_type, PerformanceCounterARM>::value &&
|
|
|
20873 std::is_same<typename PerformanceCounterDescriptionARMAllocator::value_type, PerformanceCounterDescriptionARM>::value,
|
|
|
20874 int>::type = 0,
|
|
|
20875 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20876 VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<PerformanceCounterARM, PerformanceCounterARMAllocator>,
|
|
|
20877 std::vector<PerformanceCounterDescriptionARM, PerformanceCounterDescriptionARMAllocator>>>::type
|
|
|
20878 enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex,
|
|
|
20879 PerformanceCounterARMAllocator & performanceCounterARMAllocator,
|
|
|
20880 PerformanceCounterDescriptionARMAllocator & performanceCounterDescriptionARMAllocator,
|
|
|
20881 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20882 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20883
|
|
|
20884 operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
|
|
|
20885 {
|
|
|
20886 return m_physicalDevice;
|
|
|
20887 }
|
|
|
20888
|
|
|
20889 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
20890 {
|
|
|
20891 return m_physicalDevice != VK_NULL_HANDLE;
|
|
|
20892 }
|
|
|
20893
|
|
|
20894 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
20895 {
|
|
|
20896 return m_physicalDevice == VK_NULL_HANDLE;
|
|
|
20897 }
|
|
|
20898
|
|
|
20899 private:
|
|
|
20900 VkPhysicalDevice m_physicalDevice = {};
|
|
|
20901 };
|
|
|
20902
|
|
|
20903 template <>
|
|
|
20904 struct CppType<ObjectType, ObjectType::ePhysicalDevice>
|
|
|
20905 {
|
|
|
20906 using Type = PhysicalDevice;
|
|
|
20907 };
|
|
|
20908
|
|
|
20909 template <>
|
|
|
20910 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::ePhysicalDevice>
|
|
|
20911 {
|
|
|
20912 using Type = PhysicalDevice;
|
|
|
20913 };
|
|
|
20914
|
|
|
20915 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
20916 template <>
|
|
|
20917 struct CppType<VkPhysicalDevice, VK_NULL_HANDLE>
|
|
|
20918 {
|
|
|
20919 using Type = PhysicalDevice;
|
|
|
20920 };
|
|
|
20921 #endif
|
|
|
20922
|
|
|
20923 template <>
|
|
|
20924 struct isVulkanHandleType<PhysicalDevice>
|
|
|
20925 {
|
|
|
20926 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
20927 };
|
|
|
20928
|
|
|
20929 // wrapper class for handle VkInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstance.html
|
|
|
20930 class Instance
|
|
|
20931 {
|
|
|
20932 public:
|
|
|
20933 using CType = VkInstance;
|
|
|
20934 using NativeType = VkInstance;
|
|
|
20935
|
|
|
20936 static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance;
|
|
|
20937 static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eInstance;
|
|
|
20938
|
|
|
20939 public:
|
|
|
20940 Instance() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
|
|
|
20941
|
|
|
20942 Instance( Instance const & rhs ) = default;
|
|
|
20943 Instance & operator=( Instance const & rhs ) = default;
|
|
|
20944
|
|
|
20945 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
|
|
|
20946 Instance( Instance && rhs ) = default;
|
|
|
20947 Instance & operator=( Instance && rhs ) = default;
|
|
|
20948 #else
|
|
|
20949 Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( exchange( rhs.m_instance, {} ) ) {}
|
|
|
20950
|
|
|
20951 Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
20952 {
|
|
|
20953 m_instance = exchange( rhs.m_instance, {} );
|
|
|
20954 return *this;
|
|
|
20955 }
|
|
|
20956 #endif
|
|
|
20957
|
|
|
20958 VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
|
|
|
20959
|
|
|
20960 Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
|
|
|
20961
|
|
|
20962 Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
|
|
|
20963 {
|
|
|
20964 m_instance = instance;
|
|
|
20965 return *this;
|
|
|
20966 }
|
|
|
20967
|
|
|
20968 Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
20969 {
|
|
|
20970 m_instance = {};
|
|
|
20971 return *this;
|
|
|
20972 }
|
|
|
20973
|
|
|
20974 //=== VK_VERSION_1_0 ===
|
|
|
20975
|
|
|
20976 // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html
|
|
|
20977 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20978 void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20980 // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html
|
|
|
20981 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20982 void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
20983 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20984 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
20985
|
|
|
20986 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
|
|
|
20987 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20988 VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount,
|
|
|
20989 PhysicalDevice * pPhysicalDevices,
|
|
|
20990 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
20991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
20992 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
|
|
|
20993 template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
|
|
|
20994 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
20995 typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, PhysicalDevice>::value, int>::type = 0,
|
|
|
20996 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
20997 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
|
|
|
20998 enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
20999 // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html
|
|
|
21000 template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
|
|
|
21001 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21002 typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, PhysicalDevice>::value, int>::type = 0,
|
|
|
21003 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21004 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
|
|
|
21005 enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21006 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21007
|
|
|
21008 // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html
|
|
|
21009 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21010 PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21012 // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html
|
|
|
21013 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21014 PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21016
|
|
|
21017 //=== VK_VERSION_1_1 ===
|
|
|
21018
|
|
|
21019 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
|
|
|
21020 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
|
|
|
21021 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21022 VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount,
|
|
|
21023 PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
|
|
|
21024 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21026 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
|
|
|
21027 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
|
|
|
21028 template <
|
|
|
21029 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
|
|
|
21030 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21031 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
|
|
|
21032 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21033 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
|
|
|
21034 enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21035 // wrapper function for command vkEnumeratePhysicalDeviceGroups, see
|
|
|
21036 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html
|
|
|
21037 template <
|
|
|
21038 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
|
|
|
21039 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21040 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
|
|
|
21041 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21042 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
|
|
|
21043 enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
|
|
|
21044 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21045 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21046
|
|
|
21047 //=== VK_KHR_surface ===
|
|
|
21048
|
|
|
21049 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
|
|
|
21050 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21051 void destroySurfaceKHR( SurfaceKHR surface,
|
|
|
21052 const AllocationCallbacks * pAllocator,
|
|
|
21053 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21055 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
|
|
|
21056 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21057 void destroySurfaceKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
21058 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21059 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21060 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21061
|
|
|
21062 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
|
|
|
21063 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21064 void destroy( SurfaceKHR surface,
|
|
|
21065 const AllocationCallbacks * pAllocator,
|
|
|
21066 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21068 // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html
|
|
|
21069 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21070 void destroy( SurfaceKHR surface,
|
|
|
21071 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21072 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21073 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21074
|
|
|
21075 //=== VK_KHR_display ===
|
|
|
21076
|
|
|
21077 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
|
|
|
21078 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
|
|
|
21079 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21080 VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR * pCreateInfo,
|
|
|
21081 const AllocationCallbacks * pAllocator,
|
|
|
21082 SurfaceKHR * pSurface,
|
|
|
21083 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21084 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21085 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
|
|
|
21086 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
|
|
|
21087 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21088 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21089 createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
|
|
|
21090 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21091 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21092 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21093 // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see
|
|
|
21094 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html
|
|
|
21095 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21096 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21097 createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
|
|
|
21098 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21099 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21100 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21101 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21102
|
|
|
21103 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
21104 //=== VK_KHR_xlib_surface ===
|
|
|
21105
|
|
|
21106 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
|
|
|
21107 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21108 VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
21109 const AllocationCallbacks * pAllocator,
|
|
|
21110 SurfaceKHR * pSurface,
|
|
|
21111 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21112 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21113 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
|
|
|
21114 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21115 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21116 createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo,
|
|
|
21117 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21118 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21119 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21120 // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html
|
|
|
21121 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21122 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21123 createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo,
|
|
|
21124 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21125 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21126 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21127 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21128 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
21129
|
|
|
21130 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
21131 //=== VK_KHR_xcb_surface ===
|
|
|
21132
|
|
|
21133 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
|
|
|
21134 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21135 VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
21136 const AllocationCallbacks * pAllocator,
|
|
|
21137 SurfaceKHR * pSurface,
|
|
|
21138 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21139 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21140 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
|
|
|
21141 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21142 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21143 createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo,
|
|
|
21144 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21145 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21146 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21147 // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html
|
|
|
21148 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21149 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21150 createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo,
|
|
|
21151 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21152 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21153 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21154 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21155 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
21156
|
|
|
21157 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
21158 //=== VK_KHR_wayland_surface ===
|
|
|
21159
|
|
|
21160 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
|
|
|
21161 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21162 VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
21163 const AllocationCallbacks * pAllocator,
|
|
|
21164 SurfaceKHR * pSurface,
|
|
|
21165 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21166 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21167 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
|
|
|
21168 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21169 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21170 createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
|
|
|
21171 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21172 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21173 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21174 // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html
|
|
|
21175 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21176 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21177 createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
|
|
|
21178 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21179 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21180 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21181 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21182 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
21183
|
|
|
21184 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
21185 //=== VK_KHR_android_surface ===
|
|
|
21186
|
|
|
21187 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
|
|
|
21188 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21189 VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
21190 const AllocationCallbacks * pAllocator,
|
|
|
21191 SurfaceKHR * pSurface,
|
|
|
21192 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21193 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21194 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
|
|
|
21195 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21196 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21197 createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
|
|
|
21198 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21199 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21200 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21201 // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html
|
|
|
21202 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21203 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21204 createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
|
|
|
21205 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21206 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21207 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21208 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21209 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
21210
|
|
|
21211 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
21212 //=== VK_KHR_win32_surface ===
|
|
|
21213
|
|
|
21214 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
|
|
|
21215 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21216 VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR * pCreateInfo,
|
|
|
21217 const AllocationCallbacks * pAllocator,
|
|
|
21218 SurfaceKHR * pSurface,
|
|
|
21219 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21220 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21221 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
|
|
|
21222 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21223 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21224 createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo,
|
|
|
21225 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21226 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21227 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21228 // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html
|
|
|
21229 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21230 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21231 createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo,
|
|
|
21232 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21233 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21234 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21235 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21236 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
21237
|
|
|
21238 //=== VK_EXT_debug_report ===
|
|
|
21239
|
|
|
21240 // wrapper function for command vkCreateDebugReportCallbackEXT, see
|
|
|
21241 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
|
|
|
21242 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21243 VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT * pCreateInfo,
|
|
|
21244 const AllocationCallbacks * pAllocator,
|
|
|
21245 DebugReportCallbackEXT * pCallback,
|
|
|
21246 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21248 // wrapper function for command vkCreateDebugReportCallbackEXT, see
|
|
|
21249 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
|
|
|
21250 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21251 VULKAN_HPP_NODISCARD typename ResultValueType<DebugReportCallbackEXT>::type
|
|
|
21252 createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo,
|
|
|
21253 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21254 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21255 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21256 // wrapper function for command vkCreateDebugReportCallbackEXT, see
|
|
|
21257 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html
|
|
|
21258 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21259 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DebugReportCallbackEXT, Dispatch>>::type
|
|
|
21260 createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
|
|
|
21261 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21262 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21263 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21265
|
|
|
21266 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
|
|
|
21267 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
|
|
|
21268 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21269 void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback,
|
|
|
21270 const AllocationCallbacks * pAllocator,
|
|
|
21271 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21272 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21273 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
|
|
|
21274 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
|
|
|
21275 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21276 void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
21277 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21278 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21280
|
|
|
21281 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
|
|
|
21282 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
|
|
|
21283 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21284 void destroy( DebugReportCallbackEXT callback,
|
|
|
21285 const AllocationCallbacks * pAllocator,
|
|
|
21286 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21288 // wrapper function for command vkDestroyDebugReportCallbackEXT, see
|
|
|
21289 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html
|
|
|
21290 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21291 void destroy( DebugReportCallbackEXT callback,
|
|
|
21292 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21293 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21295
|
|
|
21296 // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html
|
|
|
21297 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21298 void debugReportMessageEXT( DebugReportFlagsEXT flags,
|
|
|
21299 DebugReportObjectTypeEXT objectType,
|
|
|
21300 uint64_t object,
|
|
|
21301 size_t location,
|
|
|
21302 int32_t messageCode,
|
|
|
21303 const char * pLayerPrefix,
|
|
|
21304 const char * pMessage,
|
|
|
21305 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21307 // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html
|
|
|
21308 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21309 void debugReportMessageEXT( DebugReportFlagsEXT flags,
|
|
|
21310 DebugReportObjectTypeEXT objectType,
|
|
|
21311 uint64_t object,
|
|
|
21312 size_t location,
|
|
|
21313 int32_t messageCode,
|
|
|
21314 const std::string & layerPrefix,
|
|
|
21315 const std::string & message,
|
|
|
21316 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21318
|
|
|
21319 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
21320 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
21321
|
|
|
21322 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
|
|
|
21323 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
|
|
|
21324 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21325 VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
|
|
|
21326 const AllocationCallbacks * pAllocator,
|
|
|
21327 SurfaceKHR * pSurface,
|
|
|
21328 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21329 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21330 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
|
|
|
21331 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
|
|
|
21332 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21333 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21334 createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
|
|
|
21335 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21336 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21337 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21338 // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see
|
|
|
21339 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html
|
|
|
21340 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21341 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21342 createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
|
|
|
21343 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21344 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21345 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21346 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21347 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
21348
|
|
|
21349 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
21350 //=== VK_NN_vi_surface ===
|
|
|
21351
|
|
|
21352 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
|
|
|
21353 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21354 VULKAN_HPP_NODISCARD Result createViSurfaceNN( const ViSurfaceCreateInfoNN * pCreateInfo,
|
|
|
21355 const AllocationCallbacks * pAllocator,
|
|
|
21356 SurfaceKHR * pSurface,
|
|
|
21357 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21358 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21359 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
|
|
|
21360 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21361 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21362 createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo,
|
|
|
21363 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21364 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21365 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21366 // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html
|
|
|
21367 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21368 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21369 createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo,
|
|
|
21370 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21371 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21372 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21373 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21374 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
21375
|
|
|
21376 //=== VK_KHR_device_group_creation ===
|
|
|
21377
|
|
|
21378 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
|
|
|
21379 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
|
|
|
21380 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21381 VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount,
|
|
|
21382 PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
|
|
|
21383 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21384 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21385 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
|
|
|
21386 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
|
|
|
21387 template <
|
|
|
21388 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
|
|
|
21389 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21390 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
|
|
|
21391 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21392 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
|
|
|
21393 enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21394 // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see
|
|
|
21395 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html
|
|
|
21396 template <
|
|
|
21397 typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
|
|
|
21398 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21399 typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0,
|
|
|
21400 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21401 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
|
|
|
21402 enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
|
|
|
21403 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21404 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21405
|
|
|
21406 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
21407 //=== VK_MVK_ios_surface ===
|
|
|
21408
|
|
|
21409 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
|
|
|
21410 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21411 VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK * pCreateInfo,
|
|
|
21412 const AllocationCallbacks * pAllocator,
|
|
|
21413 SurfaceKHR * pSurface,
|
|
|
21414 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21415 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21416 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
|
|
|
21417 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21418 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21419 createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo,
|
|
|
21420 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21421 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21422 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21423 // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html
|
|
|
21424 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21425 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21426 createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo,
|
|
|
21427 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21428 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21429 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21430 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21431 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
21432
|
|
|
21433 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
21434 //=== VK_MVK_macos_surface ===
|
|
|
21435
|
|
|
21436 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
|
|
|
21437 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21438 VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK * pCreateInfo,
|
|
|
21439 const AllocationCallbacks * pAllocator,
|
|
|
21440 SurfaceKHR * pSurface,
|
|
|
21441 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21442 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21443 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
|
|
|
21444 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21445 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21446 createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo,
|
|
|
21447 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21448 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21449 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21450 // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html
|
|
|
21451 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21452 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21453 createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo,
|
|
|
21454 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21455 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21456 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21457 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21458 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
21459
|
|
|
21460 //=== VK_EXT_debug_utils ===
|
|
|
21461
|
|
|
21462 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
|
|
|
21463 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
|
|
|
21464 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21465 VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
|
|
|
21466 const AllocationCallbacks * pAllocator,
|
|
|
21467 DebugUtilsMessengerEXT * pMessenger,
|
|
|
21468 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21470 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
|
|
|
21471 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
|
|
|
21472 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21473 VULKAN_HPP_NODISCARD typename ResultValueType<DebugUtilsMessengerEXT>::type
|
|
|
21474 createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo,
|
|
|
21475 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21476 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21477 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21478 // wrapper function for command vkCreateDebugUtilsMessengerEXT, see
|
|
|
21479 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html
|
|
|
21480 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21481 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT, Dispatch>>::type
|
|
|
21482 createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
|
|
|
21483 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21484 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21485 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21486 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21487
|
|
|
21488 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
|
|
|
21489 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
|
|
|
21490 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21491 void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger,
|
|
|
21492 const AllocationCallbacks * pAllocator,
|
|
|
21493 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21495 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
|
|
|
21496 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
|
|
|
21497 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21498 void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
|
|
|
21499 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21500 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21502
|
|
|
21503 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
|
|
|
21504 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
|
|
|
21505 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21506 void destroy( DebugUtilsMessengerEXT messenger,
|
|
|
21507 const AllocationCallbacks * pAllocator,
|
|
|
21508 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21510 // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see
|
|
|
21511 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html
|
|
|
21512 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21513 void destroy( DebugUtilsMessengerEXT messenger,
|
|
|
21514 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21515 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21516 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21517
|
|
|
21518 // wrapper function for command vkSubmitDebugUtilsMessageEXT, see
|
|
|
21519 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html
|
|
|
21520 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21521 void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
|
|
21522 DebugUtilsMessageTypeFlagsEXT messageTypes,
|
|
|
21523 const DebugUtilsMessengerCallbackDataEXT * pCallbackData,
|
|
|
21524 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21525 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21526 // wrapper function for command vkSubmitDebugUtilsMessageEXT, see
|
|
|
21527 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html
|
|
|
21528 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21529 void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
|
|
21530 DebugUtilsMessageTypeFlagsEXT messageTypes,
|
|
|
21531 const DebugUtilsMessengerCallbackDataEXT & callbackData,
|
|
|
21532 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21533 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21534
|
|
|
21535 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
21536 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
21537
|
|
|
21538 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
|
|
|
21539 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
|
|
|
21540 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21541 VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
|
|
|
21542 const AllocationCallbacks * pAllocator,
|
|
|
21543 SurfaceKHR * pSurface,
|
|
|
21544 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21545 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21546 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
|
|
|
21547 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
|
|
|
21548 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21549 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21550 createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
|
|
|
21551 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21552 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21553 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21554 // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see
|
|
|
21555 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html
|
|
|
21556 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21557 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21558 createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
|
|
|
21559 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21560 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21561 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21562 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21563 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
21564
|
|
|
21565 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
21566 //=== VK_EXT_metal_surface ===
|
|
|
21567
|
|
|
21568 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
|
|
|
21569 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21570 VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT * pCreateInfo,
|
|
|
21571 const AllocationCallbacks * pAllocator,
|
|
|
21572 SurfaceKHR * pSurface,
|
|
|
21573 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21574 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21575 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
|
|
|
21576 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21577 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21578 createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo,
|
|
|
21579 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21580 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21581 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21582 // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html
|
|
|
21583 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21584 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21585 createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo,
|
|
|
21586 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21587 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21588 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21589 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21590 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
21591
|
|
|
21592 //=== VK_EXT_headless_surface ===
|
|
|
21593
|
|
|
21594 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
|
|
|
21595 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21596 VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT * pCreateInfo,
|
|
|
21597 const AllocationCallbacks * pAllocator,
|
|
|
21598 SurfaceKHR * pSurface,
|
|
|
21599 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21600 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21601 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
|
|
|
21602 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21603 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21604 createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
|
|
|
21605 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21606 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21607 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21608 // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html
|
|
|
21609 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21610 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21611 createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
|
|
|
21612 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21613 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21614 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21615 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21616
|
|
|
21617 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
21618 //=== VK_EXT_directfb_surface ===
|
|
|
21619
|
|
|
21620 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
|
|
|
21621 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21622 VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT * pCreateInfo,
|
|
|
21623 const AllocationCallbacks * pAllocator,
|
|
|
21624 SurfaceKHR * pSurface,
|
|
|
21625 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21626 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21627 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
|
|
|
21628 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21629 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21630 createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
|
|
|
21631 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21632 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21633 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21634 // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html
|
|
|
21635 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21636 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21637 createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
|
|
|
21638 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21639 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21640 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21641 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21642 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
21643
|
|
|
21644 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
21645 //=== VK_QNX_screen_surface ===
|
|
|
21646
|
|
|
21647 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
|
|
|
21648 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21649 VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX * pCreateInfo,
|
|
|
21650 const AllocationCallbacks * pAllocator,
|
|
|
21651 SurfaceKHR * pSurface,
|
|
|
21652 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21653 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21654 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
|
|
|
21655 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21656 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21657 createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo,
|
|
|
21658 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21659 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21660 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21661 // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html
|
|
|
21662 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21663 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21664 createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo,
|
|
|
21665 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21666 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21667 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21668 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21669 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
21670
|
|
|
21671 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
21672 //=== VK_OHOS_surface ===
|
|
|
21673
|
|
|
21674 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
|
|
|
21675 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21676 VULKAN_HPP_NODISCARD Result createSurfaceOHOS( const SurfaceCreateInfoOHOS * pCreateInfo,
|
|
|
21677 const AllocationCallbacks * pAllocator,
|
|
|
21678 SurfaceKHR * pSurface,
|
|
|
21679 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
|
|
21680 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21681 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
|
|
|
21682 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21683 VULKAN_HPP_NODISCARD typename ResultValueType<SurfaceKHR>::type
|
|
|
21684 createSurfaceOHOS( const SurfaceCreateInfoOHOS & createInfo,
|
|
|
21685 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21686 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21687 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21688 // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
|
|
|
21689 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21690 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
|
|
|
21691 createSurfaceOHOSUnique( const SurfaceCreateInfoOHOS & createInfo,
|
|
|
21692 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21693 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
|
|
21694 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21695 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21696 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
21697
|
|
|
21698 operator VkInstance() const VULKAN_HPP_NOEXCEPT
|
|
|
21699 {
|
|
|
21700 return m_instance;
|
|
|
21701 }
|
|
|
21702
|
|
|
21703 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
21704 {
|
|
|
21705 return m_instance != VK_NULL_HANDLE;
|
|
|
21706 }
|
|
|
21707
|
|
|
21708 bool operator!() const VULKAN_HPP_NOEXCEPT
|
|
|
21709 {
|
|
|
21710 return m_instance == VK_NULL_HANDLE;
|
|
|
21711 }
|
|
|
21712
|
|
|
21713 private:
|
|
|
21714 VkInstance m_instance = {};
|
|
|
21715 };
|
|
|
21716
|
|
|
21717 template <>
|
|
|
21718 struct CppType<ObjectType, ObjectType::eInstance>
|
|
|
21719 {
|
|
|
21720 using Type = Instance;
|
|
|
21721 };
|
|
|
21722
|
|
|
21723 template <>
|
|
|
21724 struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eInstance>
|
|
|
21725 {
|
|
|
21726 using Type = Instance;
|
|
|
21727 };
|
|
|
21728
|
|
|
21729 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
|
21730 template <>
|
|
|
21731 struct CppType<VkInstance, VK_NULL_HANDLE>
|
|
|
21732 {
|
|
|
21733 using Type = Instance;
|
|
|
21734 };
|
|
|
21735 #endif
|
|
|
21736
|
|
|
21737 template <>
|
|
|
21738 struct isVulkanHandleType<Instance>
|
|
|
21739 {
|
|
|
21740 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
21741 };
|
|
|
21742
|
|
|
21743 //=== VK_VERSION_1_0 ===
|
|
|
21744
|
|
|
21745 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
|
|
|
21746 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21747 VULKAN_HPP_NODISCARD Result createInstance( const InstanceCreateInfo * pCreateInfo,
|
|
|
21748 const AllocationCallbacks * pAllocator,
|
|
|
21749 Instance * pInstance,
|
|
|
21750 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
|
|
|
21751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21752 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
|
|
|
21753 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21754 VULKAN_HPP_NODISCARD typename ResultValueType<Instance>::type
|
|
|
21755 createInstance( const InstanceCreateInfo & createInfo,
|
|
|
21756 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21757 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
|
|
|
21758 # ifndef VULKAN_HPP_NO_SMART_HANDLE
|
|
|
21759 // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html
|
|
|
21760 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21761 VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<Instance, Dispatch>>::type
|
|
|
21762 createInstanceUnique( const InstanceCreateInfo & createInfo,
|
|
|
21763 Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21764 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
|
|
|
21765 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
|
|
|
21766 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21767
|
|
|
21768 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
|
|
|
21769 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
|
|
|
21770 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21771 VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char * pLayerName,
|
|
|
21772 uint32_t * pPropertyCount,
|
|
|
21773 ExtensionProperties * pProperties,
|
|
|
21774 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
|
|
|
21775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21776 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
|
|
|
21777 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
|
|
|
21778 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
|
|
|
21779 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21780 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
|
|
|
21781 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21782 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
|
|
|
21783 enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
21784 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
|
|
|
21785 // wrapper function for command vkEnumerateInstanceExtensionProperties, see
|
|
|
21786 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html
|
|
|
21787 template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
|
|
|
21788 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21789 typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, ExtensionProperties>::value, int>::type = 0,
|
|
|
21790 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21791 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
|
|
|
21792 enumerateInstanceExtensionProperties( Optional<const std::string> layerName,
|
|
|
21793 ExtensionPropertiesAllocator & extensionPropertiesAllocator,
|
|
|
21794 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
|
|
|
21795 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21796
|
|
|
21797 // wrapper function for command vkEnumerateInstanceLayerProperties, see
|
|
|
21798 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
|
|
|
21799 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21800 VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount,
|
|
|
21801 LayerProperties * pProperties,
|
|
|
21802 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
|
|
|
21803 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21804 // wrapper function for command vkEnumerateInstanceLayerProperties, see
|
|
|
21805 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
|
|
|
21806 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
|
|
|
21807 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21808 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
|
|
|
21809 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21810 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
|
|
|
21811 enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
|
|
|
21812 // wrapper function for command vkEnumerateInstanceLayerProperties, see
|
|
|
21813 // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html
|
|
|
21814 template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
|
|
|
21815 typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
|
|
|
21816 typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, LayerProperties>::value, int>::type = 0,
|
|
|
21817 typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21818 VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
|
|
|
21819 enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
|
|
|
21820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21821
|
|
|
21822 //=== VK_VERSION_1_1 ===
|
|
|
21823
|
|
|
21824 // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html
|
|
|
21825 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21826 VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion,
|
|
|
21827 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
|
|
|
21828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
21829 // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html
|
|
|
21830 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
|
|
|
21831 VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
|
|
|
21832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
|
|
21833
|
|
|
21834 // operators to compare VULKAN_HPP_NAMESPACE::-handles
|
|
|
21835 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21836 bool operator==( T const & lhs, T const & rhs )
|
|
|
21837 {
|
|
|
21838 return static_cast<typename T::NativeType>( lhs ) == static_cast<typename T::NativeType>( rhs );
|
|
|
21839 }
|
|
|
21840
|
|
|
21841 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21842 bool operator!=( T const & lhs, T const & rhs )
|
|
|
21843 {
|
|
|
21844 return static_cast<typename T::NativeType>( lhs ) != static_cast<typename T::NativeType>( rhs );
|
|
|
21845 }
|
|
|
21846
|
|
|
21847 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21848 bool operator<( T const & lhs, T const & rhs )
|
|
|
21849 {
|
|
|
21850 return static_cast<typename T::NativeType>( lhs ) < static_cast<typename T::NativeType>( rhs );
|
|
|
21851 }
|
|
|
21852
|
|
|
21853 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21854 bool operator<=( T const & lhs, T const & rhs )
|
|
|
21855 {
|
|
|
21856 return static_cast<typename T::NativeType>( lhs ) <= static_cast<typename T::NativeType>( rhs );
|
|
|
21857 }
|
|
|
21858
|
|
|
21859 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21860 bool operator>( T const & lhs, T const & rhs )
|
|
|
21861 {
|
|
|
21862 return static_cast<typename T::NativeType>( lhs ) > static_cast<typename T::NativeType>( rhs );
|
|
|
21863 }
|
|
|
21864
|
|
|
21865 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21866 bool operator>=( T const & lhs, T const & rhs )
|
|
|
21867 {
|
|
|
21868 return static_cast<typename T::NativeType>( lhs ) >= static_cast<typename T::NativeType>( rhs );
|
|
|
21869 }
|
|
|
21870
|
|
|
21871 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21872 bool operator==( T const & v, std::nullptr_t )
|
|
|
21873 {
|
|
|
21874 return !v;
|
|
|
21875 }
|
|
|
21876
|
|
|
21877 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21878 bool operator==( std::nullptr_t, T const & v )
|
|
|
21879 {
|
|
|
21880 return !v;
|
|
|
21881 }
|
|
|
21882
|
|
|
21883 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21884 bool operator!=( T const & v, std::nullptr_t )
|
|
|
21885 {
|
|
|
21886 return !!v;
|
|
|
21887 }
|
|
|
21888
|
|
|
21889 template <typename T, typename std::enable_if<isVulkanHandleType<T>::value, int>::type = 0>
|
|
|
21890 bool operator!=( std::nullptr_t, T const & v )
|
|
|
21891 {
|
|
|
21892 return !!v;
|
|
|
21893 }
|
|
|
21894 } // namespace VULKAN_HPP_NAMESPACE
|
|
|
21895 #endif
|