1 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
2 // See object_tracker_generator.py for modifications
3
4
5 /***************************************************************************
6 *
7 * Copyright (c) 2015-2020 The Khronos Group Inc.
8 * Copyright (c) 2015-2020 Valve Corporation
9 * Copyright (c) 2015-2020 LunarG, Inc.
10 * Copyright (c) 2015-2020 Google Inc.
11 *
12 * Licensed under the Apache License, Version 2.0 (the "License");
13 * you may not use this file except in compliance with the License.
14 * You may obtain a copy of the License at
15 *
16 * http://www.apache.org/licenses/LICENSE-2.0
17 *
18 * Unless required by applicable law or agreed to in writing, software
19 * distributed under the License is distributed on an "AS IS" BASIS,
20 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 * See the License for the specific language governing permissions and
22 * limitations under the License.
23 *
24 * Author: Mark Lobodzinski <mark@lunarg.com>
25 * Author: Dave Houlton <daveh@lunarg.com>
26 *
27 ****************************************************************************/
28
29
30 #include "chassis.h"
31 #include "object_lifetime_validation.h"
32
33
34
35 // ObjectTracker undestroyed objects validation function
ReportUndestroyedInstanceObjects(VkInstance instance,const std::string & error_code) const36 bool ObjectLifetimes::ReportUndestroyedInstanceObjects(VkInstance instance, const std::string& error_code) const {
37 bool skip = false;
38 skip |= ReportLeakedInstanceObjects(instance, kVulkanObjectTypeSurfaceKHR, error_code);
39 skip |= ReportLeakedInstanceObjects(instance, kVulkanObjectTypeSwapchainKHR, error_code);
40 // No destroy API -- do not report: skip |= ReportLeakedInstanceObjects(instance, kVulkanObjectTypeDisplayKHR, error_code);
41 // No destroy API -- do not report: skip |= ReportLeakedInstanceObjects(instance, kVulkanObjectTypeDisplayModeKHR, error_code);
42 skip |= ReportLeakedInstanceObjects(instance, kVulkanObjectTypeDebugReportCallbackEXT, error_code);
43 skip |= ReportLeakedInstanceObjects(instance, kVulkanObjectTypeDebugUtilsMessengerEXT, error_code);
44 return skip;
45 }
ReportUndestroyedDeviceObjects(VkDevice device,const std::string & error_code) const46 bool ObjectLifetimes::ReportUndestroyedDeviceObjects(VkDevice device, const std::string& error_code) const {
47 bool skip = false;
48 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeCommandBuffer, error_code);
49 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeBuffer, error_code);
50 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeImage, error_code);
51 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeSemaphore, error_code);
52 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeFence, error_code);
53 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeDeviceMemory, error_code);
54 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeEvent, error_code);
55 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeQueryPool, error_code);
56 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeBufferView, error_code);
57 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeImageView, error_code);
58 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeShaderModule, error_code);
59 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypePipelineCache, error_code);
60 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypePipelineLayout, error_code);
61 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypePipeline, error_code);
62 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeRenderPass, error_code);
63 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeDescriptorSetLayout, error_code);
64 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeSampler, error_code);
65 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeDescriptorSet, error_code);
66 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeDescriptorPool, error_code);
67 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeFramebuffer, error_code);
68 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeCommandPool, error_code);
69 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeSamplerYcbcrConversion, error_code);
70 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeDescriptorUpdateTemplate, error_code);
71 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeDeferredOperationKHR, error_code);
72 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeValidationCacheEXT, error_code);
73 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeAccelerationStructureKHR, error_code);
74 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypePerformanceConfigurationINTEL, error_code);
75 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNV, error_code);
76 skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypePrivateDataSlotEXT, error_code);
77 return skip;
78 }
79
DestroyLeakedInstanceObjects()80 void ObjectLifetimes::DestroyLeakedInstanceObjects() {
81 DestroyUndestroyedObjects(kVulkanObjectTypeSurfaceKHR);
82 DestroyUndestroyedObjects(kVulkanObjectTypeSwapchainKHR);
83 DestroyUndestroyedObjects(kVulkanObjectTypeDisplayKHR);
84 DestroyUndestroyedObjects(kVulkanObjectTypeDisplayModeKHR);
85 DestroyUndestroyedObjects(kVulkanObjectTypeDebugReportCallbackEXT);
86 DestroyUndestroyedObjects(kVulkanObjectTypeDebugUtilsMessengerEXT);
87 }
DestroyLeakedDeviceObjects()88 void ObjectLifetimes::DestroyLeakedDeviceObjects() {
89 DestroyUndestroyedObjects(kVulkanObjectTypeCommandBuffer);
90 DestroyUndestroyedObjects(kVulkanObjectTypeBuffer);
91 DestroyUndestroyedObjects(kVulkanObjectTypeImage);
92 DestroyUndestroyedObjects(kVulkanObjectTypeSemaphore);
93 DestroyUndestroyedObjects(kVulkanObjectTypeFence);
94 DestroyUndestroyedObjects(kVulkanObjectTypeDeviceMemory);
95 DestroyUndestroyedObjects(kVulkanObjectTypeEvent);
96 DestroyUndestroyedObjects(kVulkanObjectTypeQueryPool);
97 DestroyUndestroyedObjects(kVulkanObjectTypeBufferView);
98 DestroyUndestroyedObjects(kVulkanObjectTypeImageView);
99 DestroyUndestroyedObjects(kVulkanObjectTypeShaderModule);
100 DestroyUndestroyedObjects(kVulkanObjectTypePipelineCache);
101 DestroyUndestroyedObjects(kVulkanObjectTypePipelineLayout);
102 DestroyUndestroyedObjects(kVulkanObjectTypePipeline);
103 DestroyUndestroyedObjects(kVulkanObjectTypeRenderPass);
104 DestroyUndestroyedObjects(kVulkanObjectTypeDescriptorSetLayout);
105 DestroyUndestroyedObjects(kVulkanObjectTypeSampler);
106 DestroyUndestroyedObjects(kVulkanObjectTypeDescriptorSet);
107 DestroyUndestroyedObjects(kVulkanObjectTypeDescriptorPool);
108 DestroyUndestroyedObjects(kVulkanObjectTypeFramebuffer);
109 DestroyUndestroyedObjects(kVulkanObjectTypeCommandPool);
110 DestroyUndestroyedObjects(kVulkanObjectTypeSamplerYcbcrConversion);
111 DestroyUndestroyedObjects(kVulkanObjectTypeDescriptorUpdateTemplate);
112 DestroyUndestroyedObjects(kVulkanObjectTypeDeferredOperationKHR);
113 DestroyUndestroyedObjects(kVulkanObjectTypeValidationCacheEXT);
114 DestroyUndestroyedObjects(kVulkanObjectTypeAccelerationStructureKHR);
115 DestroyUndestroyedObjects(kVulkanObjectTypePerformanceConfigurationINTEL);
116 DestroyUndestroyedObjects(kVulkanObjectTypeIndirectCommandsLayoutNV);
117 DestroyUndestroyedObjects(kVulkanObjectTypePrivateDataSlotEXT);
118 }
119
120
121
PreCallValidateGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures) const122 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFeatures(
123 VkPhysicalDevice physicalDevice,
124 VkPhysicalDeviceFeatures* pFeatures) const {
125 bool skip = false;
126 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter", kVUIDUndefined);
127
128 return skip;
129 }
130
PreCallValidateGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties) const131 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFormatProperties(
132 VkPhysicalDevice physicalDevice,
133 VkFormat format,
134 VkFormatProperties* pFormatProperties) const {
135 bool skip = false;
136 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter", kVUIDUndefined);
137
138 return skip;
139 }
140
PreCallValidateGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties) const141 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceImageFormatProperties(
142 VkPhysicalDevice physicalDevice,
143 VkFormat format,
144 VkImageType type,
145 VkImageTiling tiling,
146 VkImageUsageFlags usage,
147 VkImageCreateFlags flags,
148 VkImageFormatProperties* pImageFormatProperties) const {
149 bool skip = false;
150 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter", kVUIDUndefined);
151
152 return skip;
153 }
154
PreCallValidateGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties) const155 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceProperties(
156 VkPhysicalDevice physicalDevice,
157 VkPhysicalDeviceProperties* pProperties) const {
158 bool skip = false;
159 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter", kVUIDUndefined);
160
161 return skip;
162 }
163
PreCallValidateGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties) const164 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMemoryProperties(
165 VkPhysicalDevice physicalDevice,
166 VkPhysicalDeviceMemoryProperties* pMemoryProperties) const {
167 bool skip = false;
168 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter", kVUIDUndefined);
169
170 return skip;
171 }
172
PreCallValidateGetInstanceProcAddr(VkInstance instance,const char * pName) const173 bool ObjectLifetimes::PreCallValidateGetInstanceProcAddr(
174 VkInstance instance,
175 const char* pName) const {
176 bool skip = false;
177 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, true, "VUID-vkGetInstanceProcAddr-instance-parameter", kVUIDUndefined);
178
179 return skip;
180 }
181
PreCallValidateGetDeviceProcAddr(VkDevice device,const char * pName) const182 bool ObjectLifetimes::PreCallValidateGetDeviceProcAddr(
183 VkDevice device,
184 const char* pName) const {
185 bool skip = false;
186 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceProcAddr-device-parameter", kVUIDUndefined);
187
188 return skip;
189 }
190
PreCallValidateEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties) const191 bool ObjectLifetimes::PreCallValidateEnumerateDeviceExtensionProperties(
192 VkPhysicalDevice physicalDevice,
193 const char* pLayerName,
194 uint32_t* pPropertyCount,
195 VkExtensionProperties* pProperties) const {
196 bool skip = false;
197 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", kVUIDUndefined);
198
199 return skip;
200 }
201
PreCallValidateEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties) const202 bool ObjectLifetimes::PreCallValidateEnumerateDeviceLayerProperties(
203 VkPhysicalDevice physicalDevice,
204 uint32_t* pPropertyCount,
205 VkLayerProperties* pProperties) const {
206 bool skip = false;
207 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", kVUIDUndefined);
208
209 return skip;
210 }
211
PreCallValidateQueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence) const212 bool ObjectLifetimes::PreCallValidateQueueSubmit(
213 VkQueue queue,
214 uint32_t submitCount,
215 const VkSubmitInfo* pSubmits,
216 VkFence fence) const {
217 bool skip = false;
218 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueSubmit-queue-parameter", "VUID-vkQueueSubmit-commonparent");
219 if (pSubmits) {
220 for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
221 if (pSubmits[index0].pWaitSemaphores) {
222 for (uint32_t index1 = 0; index1 < pSubmits[index0].waitSemaphoreCount; ++index1) {
223 skip |= ValidateObject(pSubmits[index0].pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkSubmitInfo-pWaitSemaphores-parameter", "VUID-VkSubmitInfo-commonparent");
224 }
225 }
226 if (pSubmits[index0].pCommandBuffers) {
227 for (uint32_t index1 = 0; index1 < pSubmits[index0].commandBufferCount; ++index1) {
228 skip |= ValidateObject(pSubmits[index0].pCommandBuffers[index1], kVulkanObjectTypeCommandBuffer, false, "VUID-VkSubmitInfo-pCommandBuffers-parameter", "VUID-VkSubmitInfo-commonparent");
229 }
230 }
231 if (pSubmits[index0].pSignalSemaphores) {
232 for (uint32_t index1 = 0; index1 < pSubmits[index0].signalSemaphoreCount; ++index1) {
233 skip |= ValidateObject(pSubmits[index0].pSignalSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkSubmitInfo-pSignalSemaphores-parameter", "VUID-VkSubmitInfo-commonparent");
234 }
235 }
236 }
237 }
238 skip |= ValidateObject(fence, kVulkanObjectTypeFence, true, "VUID-vkQueueSubmit-fence-parameter", "VUID-vkQueueSubmit-commonparent");
239
240 return skip;
241 }
242
PreCallValidateQueueWaitIdle(VkQueue queue) const243 bool ObjectLifetimes::PreCallValidateQueueWaitIdle(
244 VkQueue queue) const {
245 bool skip = false;
246 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueWaitIdle-queue-parameter", kVUIDUndefined);
247
248 return skip;
249 }
250
PreCallValidateDeviceWaitIdle(VkDevice device) const251 bool ObjectLifetimes::PreCallValidateDeviceWaitIdle(
252 VkDevice device) const {
253 bool skip = false;
254 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDeviceWaitIdle-device-parameter", kVUIDUndefined);
255
256 return skip;
257 }
258
PreCallValidateAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory) const259 bool ObjectLifetimes::PreCallValidateAllocateMemory(
260 VkDevice device,
261 const VkMemoryAllocateInfo* pAllocateInfo,
262 const VkAllocationCallbacks* pAllocator,
263 VkDeviceMemory* pMemory) const {
264 bool skip = false;
265 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateMemory-device-parameter", kVUIDUndefined);
266
267 return skip;
268 }
269
PostCallRecordAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory,VkResult result)270 void ObjectLifetimes::PostCallRecordAllocateMemory(
271 VkDevice device,
272 const VkMemoryAllocateInfo* pAllocateInfo,
273 const VkAllocationCallbacks* pAllocator,
274 VkDeviceMemory* pMemory,
275 VkResult result) {
276 if (result != VK_SUCCESS) return;
277 CreateObject(*pMemory, kVulkanObjectTypeDeviceMemory, pAllocator);
278
279 }
280
PreCallValidateFreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator) const281 bool ObjectLifetimes::PreCallValidateFreeMemory(
282 VkDevice device,
283 VkDeviceMemory memory,
284 const VkAllocationCallbacks* pAllocator) const {
285 bool skip = false;
286 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkFreeMemory-device-parameter", kVUIDUndefined);
287 skip |= ValidateObject(memory, kVulkanObjectTypeDeviceMemory, true, "VUID-vkFreeMemory-memory-parameter", "VUID-vkFreeMemory-memory-parent");
288 skip |= ValidateDestroyObject(memory, kVulkanObjectTypeDeviceMemory, pAllocator, kVUIDUndefined, kVUIDUndefined);
289
290 return skip;
291 }
292
PreCallRecordFreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)293 void ObjectLifetimes::PreCallRecordFreeMemory(
294 VkDevice device,
295 VkDeviceMemory memory,
296 const VkAllocationCallbacks* pAllocator) {
297 RecordDestroyObject(memory, kVulkanObjectTypeDeviceMemory);
298
299 }
300
PreCallValidateMapMemory(VkDevice device,VkDeviceMemory memory,VkDeviceSize offset,VkDeviceSize size,VkMemoryMapFlags flags,void ** ppData) const301 bool ObjectLifetimes::PreCallValidateMapMemory(
302 VkDevice device,
303 VkDeviceMemory memory,
304 VkDeviceSize offset,
305 VkDeviceSize size,
306 VkMemoryMapFlags flags,
307 void** ppData) const {
308 bool skip = false;
309 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkMapMemory-device-parameter", kVUIDUndefined);
310 skip |= ValidateObject(memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkMapMemory-memory-parameter", "VUID-vkMapMemory-memory-parent");
311
312 return skip;
313 }
314
PreCallValidateUnmapMemory(VkDevice device,VkDeviceMemory memory) const315 bool ObjectLifetimes::PreCallValidateUnmapMemory(
316 VkDevice device,
317 VkDeviceMemory memory) const {
318 bool skip = false;
319 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkUnmapMemory-device-parameter", kVUIDUndefined);
320 skip |= ValidateObject(memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkUnmapMemory-memory-parameter", "VUID-vkUnmapMemory-memory-parent");
321
322 return skip;
323 }
324
PreCallValidateFlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges) const325 bool ObjectLifetimes::PreCallValidateFlushMappedMemoryRanges(
326 VkDevice device,
327 uint32_t memoryRangeCount,
328 const VkMappedMemoryRange* pMemoryRanges) const {
329 bool skip = false;
330 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkFlushMappedMemoryRanges-device-parameter", kVUIDUndefined);
331 if (pMemoryRanges) {
332 for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
333 skip |= ValidateObject(pMemoryRanges[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMappedMemoryRange-memory-parameter", kVUIDUndefined);
334 }
335 }
336
337 return skip;
338 }
339
PreCallValidateInvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges) const340 bool ObjectLifetimes::PreCallValidateInvalidateMappedMemoryRanges(
341 VkDevice device,
342 uint32_t memoryRangeCount,
343 const VkMappedMemoryRange* pMemoryRanges) const {
344 bool skip = false;
345 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkInvalidateMappedMemoryRanges-device-parameter", kVUIDUndefined);
346 if (pMemoryRanges) {
347 for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
348 skip |= ValidateObject(pMemoryRanges[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMappedMemoryRange-memory-parameter", kVUIDUndefined);
349 }
350 }
351
352 return skip;
353 }
354
PreCallValidateGetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes) const355 bool ObjectLifetimes::PreCallValidateGetDeviceMemoryCommitment(
356 VkDevice device,
357 VkDeviceMemory memory,
358 VkDeviceSize* pCommittedMemoryInBytes) const {
359 bool skip = false;
360 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceMemoryCommitment-device-parameter", kVUIDUndefined);
361 skip |= ValidateObject(memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkGetDeviceMemoryCommitment-memory-parameter", "VUID-vkGetDeviceMemoryCommitment-memory-parent");
362
363 return skip;
364 }
365
PreCallValidateBindBufferMemory(VkDevice device,VkBuffer buffer,VkDeviceMemory memory,VkDeviceSize memoryOffset) const366 bool ObjectLifetimes::PreCallValidateBindBufferMemory(
367 VkDevice device,
368 VkBuffer buffer,
369 VkDeviceMemory memory,
370 VkDeviceSize memoryOffset) const {
371 bool skip = false;
372 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindBufferMemory-device-parameter", kVUIDUndefined);
373 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkBindBufferMemory-buffer-parameter", "VUID-vkBindBufferMemory-buffer-parent");
374 skip |= ValidateObject(memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkBindBufferMemory-memory-parameter", "VUID-vkBindBufferMemory-memory-parent");
375
376 return skip;
377 }
378
PreCallValidateBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset) const379 bool ObjectLifetimes::PreCallValidateBindImageMemory(
380 VkDevice device,
381 VkImage image,
382 VkDeviceMemory memory,
383 VkDeviceSize memoryOffset) const {
384 bool skip = false;
385 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindImageMemory-device-parameter", kVUIDUndefined);
386 skip |= ValidateObject(image, kVulkanObjectTypeImage, false, "VUID-vkBindImageMemory-image-parameter", "VUID-vkBindImageMemory-image-parent");
387 skip |= ValidateObject(memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkBindImageMemory-memory-parameter", "VUID-vkBindImageMemory-memory-parent");
388
389 return skip;
390 }
391
PreCallValidateGetBufferMemoryRequirements(VkDevice device,VkBuffer buffer,VkMemoryRequirements * pMemoryRequirements) const392 bool ObjectLifetimes::PreCallValidateGetBufferMemoryRequirements(
393 VkDevice device,
394 VkBuffer buffer,
395 VkMemoryRequirements* pMemoryRequirements) const {
396 bool skip = false;
397 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferMemoryRequirements-device-parameter", kVUIDUndefined);
398 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkGetBufferMemoryRequirements-buffer-parameter", "VUID-vkGetBufferMemoryRequirements-buffer-parent");
399
400 return skip;
401 }
402
PreCallValidateGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements) const403 bool ObjectLifetimes::PreCallValidateGetImageMemoryRequirements(
404 VkDevice device,
405 VkImage image,
406 VkMemoryRequirements* pMemoryRequirements) const {
407 bool skip = false;
408 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageMemoryRequirements-device-parameter", kVUIDUndefined);
409 skip |= ValidateObject(image, kVulkanObjectTypeImage, false, "VUID-vkGetImageMemoryRequirements-image-parameter", "VUID-vkGetImageMemoryRequirements-image-parent");
410
411 return skip;
412 }
413
PreCallValidateGetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements) const414 bool ObjectLifetimes::PreCallValidateGetImageSparseMemoryRequirements(
415 VkDevice device,
416 VkImage image,
417 uint32_t* pSparseMemoryRequirementCount,
418 VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const {
419 bool skip = false;
420 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSparseMemoryRequirements-device-parameter", kVUIDUndefined);
421 skip |= ValidateObject(image, kVulkanObjectTypeImage, false, "VUID-vkGetImageSparseMemoryRequirements-image-parameter", "VUID-vkGetImageSparseMemoryRequirements-image-parent");
422
423 return skip;
424 }
425
PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties) const426 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(
427 VkPhysicalDevice physicalDevice,
428 VkFormat format,
429 VkImageType type,
430 VkSampleCountFlagBits samples,
431 VkImageUsageFlags usage,
432 VkImageTiling tiling,
433 uint32_t* pPropertyCount,
434 VkSparseImageFormatProperties* pProperties) const {
435 bool skip = false;
436 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter", kVUIDUndefined);
437
438 return skip;
439 }
440
PreCallValidateQueueBindSparse(VkQueue queue,uint32_t bindInfoCount,const VkBindSparseInfo * pBindInfo,VkFence fence) const441 bool ObjectLifetimes::PreCallValidateQueueBindSparse(
442 VkQueue queue,
443 uint32_t bindInfoCount,
444 const VkBindSparseInfo* pBindInfo,
445 VkFence fence) const {
446 bool skip = false;
447 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueBindSparse-queue-parameter", "VUID-vkQueueBindSparse-commonparent");
448 if (pBindInfo) {
449 for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
450 if (pBindInfo[index0].pWaitSemaphores) {
451 for (uint32_t index1 = 0; index1 < pBindInfo[index0].waitSemaphoreCount; ++index1) {
452 skip |= ValidateObject(pBindInfo[index0].pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkBindSparseInfo-pWaitSemaphores-parameter", "VUID-VkBindSparseInfo-commonparent");
453 }
454 }
455 if (pBindInfo[index0].pBufferBinds) {
456 for (uint32_t index1 = 0; index1 < pBindInfo[index0].bufferBindCount; ++index1) {
457 skip |= ValidateObject(pBindInfo[index0].pBufferBinds[index1].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkSparseBufferMemoryBindInfo-buffer-parameter", kVUIDUndefined);
458 if (pBindInfo[index0].pBufferBinds[index1].pBinds) {
459 for (uint32_t index2 = 0; index2 < pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) {
460 skip |= ValidateObject(pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, "VUID-VkSparseMemoryBind-memory-parameter", kVUIDUndefined);
461 }
462 }
463 }
464 }
465 if (pBindInfo[index0].pImageOpaqueBinds) {
466 for (uint32_t index1 = 0; index1 < pBindInfo[index0].imageOpaqueBindCount; ++index1) {
467 skip |= ValidateObject(pBindInfo[index0].pImageOpaqueBinds[index1].image, kVulkanObjectTypeImage, false, "VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter", kVUIDUndefined);
468 if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) {
469 for (uint32_t index2 = 0; index2 < pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) {
470 skip |= ValidateObject(pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, "VUID-VkSparseMemoryBind-memory-parameter", kVUIDUndefined);
471 }
472 }
473 }
474 }
475 if (pBindInfo[index0].pImageBinds) {
476 for (uint32_t index1 = 0; index1 < pBindInfo[index0].imageBindCount; ++index1) {
477 skip |= ValidateObject(pBindInfo[index0].pImageBinds[index1].image, kVulkanObjectTypeImage, false, "VUID-VkSparseImageMemoryBindInfo-image-parameter", kVUIDUndefined);
478 if (pBindInfo[index0].pImageBinds[index1].pBinds) {
479 for (uint32_t index2 = 0; index2 < pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) {
480 skip |= ValidateObject(pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, "VUID-VkSparseImageMemoryBind-memory-parameter", kVUIDUndefined);
481 }
482 }
483 }
484 }
485 if (pBindInfo[index0].pSignalSemaphores) {
486 for (uint32_t index1 = 0; index1 < pBindInfo[index0].signalSemaphoreCount; ++index1) {
487 skip |= ValidateObject(pBindInfo[index0].pSignalSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkBindSparseInfo-pSignalSemaphores-parameter", "VUID-VkBindSparseInfo-commonparent");
488 }
489 }
490 }
491 }
492 skip |= ValidateObject(fence, kVulkanObjectTypeFence, true, "VUID-vkQueueBindSparse-fence-parameter", "VUID-vkQueueBindSparse-commonparent");
493
494 return skip;
495 }
496
PreCallValidateCreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const497 bool ObjectLifetimes::PreCallValidateCreateFence(
498 VkDevice device,
499 const VkFenceCreateInfo* pCreateInfo,
500 const VkAllocationCallbacks* pAllocator,
501 VkFence* pFence) const {
502 bool skip = false;
503 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateFence-device-parameter", kVUIDUndefined);
504
505 return skip;
506 }
507
PostCallRecordCreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence,VkResult result)508 void ObjectLifetimes::PostCallRecordCreateFence(
509 VkDevice device,
510 const VkFenceCreateInfo* pCreateInfo,
511 const VkAllocationCallbacks* pAllocator,
512 VkFence* pFence,
513 VkResult result) {
514 if (result != VK_SUCCESS) return;
515 CreateObject(*pFence, kVulkanObjectTypeFence, pAllocator);
516
517 }
518
PreCallValidateDestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator) const519 bool ObjectLifetimes::PreCallValidateDestroyFence(
520 VkDevice device,
521 VkFence fence,
522 const VkAllocationCallbacks* pAllocator) const {
523 bool skip = false;
524 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyFence-device-parameter", kVUIDUndefined);
525 skip |= ValidateObject(fence, kVulkanObjectTypeFence, true, "VUID-vkDestroyFence-fence-parameter", "VUID-vkDestroyFence-fence-parent");
526 skip |= ValidateDestroyObject(fence, kVulkanObjectTypeFence, pAllocator, "VUID-vkDestroyFence-fence-01121", "VUID-vkDestroyFence-fence-01122");
527
528 return skip;
529 }
530
PreCallRecordDestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator)531 void ObjectLifetimes::PreCallRecordDestroyFence(
532 VkDevice device,
533 VkFence fence,
534 const VkAllocationCallbacks* pAllocator) {
535 RecordDestroyObject(fence, kVulkanObjectTypeFence);
536
537 }
538
PreCallValidateResetFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences) const539 bool ObjectLifetimes::PreCallValidateResetFences(
540 VkDevice device,
541 uint32_t fenceCount,
542 const VkFence* pFences) const {
543 bool skip = false;
544 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkResetFences-device-parameter", kVUIDUndefined);
545 if (pFences) {
546 for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
547 skip |= ValidateObject(pFences[index0], kVulkanObjectTypeFence, false, "VUID-vkResetFences-pFences-parameter", "VUID-vkResetFences-pFences-parent");
548 }
549 }
550
551 return skip;
552 }
553
PreCallValidateGetFenceStatus(VkDevice device,VkFence fence) const554 bool ObjectLifetimes::PreCallValidateGetFenceStatus(
555 VkDevice device,
556 VkFence fence) const {
557 bool skip = false;
558 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetFenceStatus-device-parameter", kVUIDUndefined);
559 skip |= ValidateObject(fence, kVulkanObjectTypeFence, false, "VUID-vkGetFenceStatus-fence-parameter", "VUID-vkGetFenceStatus-fence-parent");
560
561 return skip;
562 }
563
PreCallValidateWaitForFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkBool32 waitAll,uint64_t timeout) const564 bool ObjectLifetimes::PreCallValidateWaitForFences(
565 VkDevice device,
566 uint32_t fenceCount,
567 const VkFence* pFences,
568 VkBool32 waitAll,
569 uint64_t timeout) const {
570 bool skip = false;
571 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkWaitForFences-device-parameter", kVUIDUndefined);
572 if (pFences) {
573 for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
574 skip |= ValidateObject(pFences[index0], kVulkanObjectTypeFence, false, "VUID-vkWaitForFences-pFences-parameter", "VUID-vkWaitForFences-pFences-parent");
575 }
576 }
577
578 return skip;
579 }
580
PreCallValidateCreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore) const581 bool ObjectLifetimes::PreCallValidateCreateSemaphore(
582 VkDevice device,
583 const VkSemaphoreCreateInfo* pCreateInfo,
584 const VkAllocationCallbacks* pAllocator,
585 VkSemaphore* pSemaphore) const {
586 bool skip = false;
587 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSemaphore-device-parameter", kVUIDUndefined);
588
589 return skip;
590 }
591
PostCallRecordCreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore,VkResult result)592 void ObjectLifetimes::PostCallRecordCreateSemaphore(
593 VkDevice device,
594 const VkSemaphoreCreateInfo* pCreateInfo,
595 const VkAllocationCallbacks* pAllocator,
596 VkSemaphore* pSemaphore,
597 VkResult result) {
598 if (result != VK_SUCCESS) return;
599 CreateObject(*pSemaphore, kVulkanObjectTypeSemaphore, pAllocator);
600
601 }
602
PreCallValidateDestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator) const603 bool ObjectLifetimes::PreCallValidateDestroySemaphore(
604 VkDevice device,
605 VkSemaphore semaphore,
606 const VkAllocationCallbacks* pAllocator) const {
607 bool skip = false;
608 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySemaphore-device-parameter", kVUIDUndefined);
609 skip |= ValidateObject(semaphore, kVulkanObjectTypeSemaphore, true, "VUID-vkDestroySemaphore-semaphore-parameter", "VUID-vkDestroySemaphore-semaphore-parent");
610 skip |= ValidateDestroyObject(semaphore, kVulkanObjectTypeSemaphore, pAllocator, "VUID-vkDestroySemaphore-semaphore-01138", "VUID-vkDestroySemaphore-semaphore-01139");
611
612 return skip;
613 }
614
PreCallRecordDestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator)615 void ObjectLifetimes::PreCallRecordDestroySemaphore(
616 VkDevice device,
617 VkSemaphore semaphore,
618 const VkAllocationCallbacks* pAllocator) {
619 RecordDestroyObject(semaphore, kVulkanObjectTypeSemaphore);
620
621 }
622
PreCallValidateCreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent) const623 bool ObjectLifetimes::PreCallValidateCreateEvent(
624 VkDevice device,
625 const VkEventCreateInfo* pCreateInfo,
626 const VkAllocationCallbacks* pAllocator,
627 VkEvent* pEvent) const {
628 bool skip = false;
629 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateEvent-device-parameter", kVUIDUndefined);
630
631 return skip;
632 }
633
PostCallRecordCreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent,VkResult result)634 void ObjectLifetimes::PostCallRecordCreateEvent(
635 VkDevice device,
636 const VkEventCreateInfo* pCreateInfo,
637 const VkAllocationCallbacks* pAllocator,
638 VkEvent* pEvent,
639 VkResult result) {
640 if (result != VK_SUCCESS) return;
641 CreateObject(*pEvent, kVulkanObjectTypeEvent, pAllocator);
642
643 }
644
PreCallValidateDestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator) const645 bool ObjectLifetimes::PreCallValidateDestroyEvent(
646 VkDevice device,
647 VkEvent event,
648 const VkAllocationCallbacks* pAllocator) const {
649 bool skip = false;
650 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyEvent-device-parameter", kVUIDUndefined);
651 skip |= ValidateObject(event, kVulkanObjectTypeEvent, true, "VUID-vkDestroyEvent-event-parameter", "VUID-vkDestroyEvent-event-parent");
652 skip |= ValidateDestroyObject(event, kVulkanObjectTypeEvent, pAllocator, "VUID-vkDestroyEvent-event-01146", "VUID-vkDestroyEvent-event-01147");
653
654 return skip;
655 }
656
PreCallRecordDestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator)657 void ObjectLifetimes::PreCallRecordDestroyEvent(
658 VkDevice device,
659 VkEvent event,
660 const VkAllocationCallbacks* pAllocator) {
661 RecordDestroyObject(event, kVulkanObjectTypeEvent);
662
663 }
664
PreCallValidateGetEventStatus(VkDevice device,VkEvent event) const665 bool ObjectLifetimes::PreCallValidateGetEventStatus(
666 VkDevice device,
667 VkEvent event) const {
668 bool skip = false;
669 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetEventStatus-device-parameter", kVUIDUndefined);
670 skip |= ValidateObject(event, kVulkanObjectTypeEvent, false, "VUID-vkGetEventStatus-event-parameter", "VUID-vkGetEventStatus-event-parent");
671
672 return skip;
673 }
674
PreCallValidateSetEvent(VkDevice device,VkEvent event) const675 bool ObjectLifetimes::PreCallValidateSetEvent(
676 VkDevice device,
677 VkEvent event) const {
678 bool skip = false;
679 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkSetEvent-device-parameter", kVUIDUndefined);
680 skip |= ValidateObject(event, kVulkanObjectTypeEvent, false, "VUID-vkSetEvent-event-parameter", "VUID-vkSetEvent-event-parent");
681
682 return skip;
683 }
684
PreCallValidateResetEvent(VkDevice device,VkEvent event) const685 bool ObjectLifetimes::PreCallValidateResetEvent(
686 VkDevice device,
687 VkEvent event) const {
688 bool skip = false;
689 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkResetEvent-device-parameter", kVUIDUndefined);
690 skip |= ValidateObject(event, kVulkanObjectTypeEvent, false, "VUID-vkResetEvent-event-parameter", "VUID-vkResetEvent-event-parent");
691
692 return skip;
693 }
694
PreCallValidateCreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool) const695 bool ObjectLifetimes::PreCallValidateCreateQueryPool(
696 VkDevice device,
697 const VkQueryPoolCreateInfo* pCreateInfo,
698 const VkAllocationCallbacks* pAllocator,
699 VkQueryPool* pQueryPool) const {
700 bool skip = false;
701 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateQueryPool-device-parameter", kVUIDUndefined);
702
703 return skip;
704 }
705
PostCallRecordCreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool,VkResult result)706 void ObjectLifetimes::PostCallRecordCreateQueryPool(
707 VkDevice device,
708 const VkQueryPoolCreateInfo* pCreateInfo,
709 const VkAllocationCallbacks* pAllocator,
710 VkQueryPool* pQueryPool,
711 VkResult result) {
712 if (result != VK_SUCCESS) return;
713 CreateObject(*pQueryPool, kVulkanObjectTypeQueryPool, pAllocator);
714
715 }
716
PreCallValidateDestroyQueryPool(VkDevice device,VkQueryPool queryPool,const VkAllocationCallbacks * pAllocator) const717 bool ObjectLifetimes::PreCallValidateDestroyQueryPool(
718 VkDevice device,
719 VkQueryPool queryPool,
720 const VkAllocationCallbacks* pAllocator) const {
721 bool skip = false;
722 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyQueryPool-device-parameter", kVUIDUndefined);
723 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, true, "VUID-vkDestroyQueryPool-queryPool-parameter", "VUID-vkDestroyQueryPool-queryPool-parent");
724 skip |= ValidateDestroyObject(queryPool, kVulkanObjectTypeQueryPool, pAllocator, "VUID-vkDestroyQueryPool-queryPool-00794", "VUID-vkDestroyQueryPool-queryPool-00795");
725
726 return skip;
727 }
728
PreCallRecordDestroyQueryPool(VkDevice device,VkQueryPool queryPool,const VkAllocationCallbacks * pAllocator)729 void ObjectLifetimes::PreCallRecordDestroyQueryPool(
730 VkDevice device,
731 VkQueryPool queryPool,
732 const VkAllocationCallbacks* pAllocator) {
733 RecordDestroyObject(queryPool, kVulkanObjectTypeQueryPool);
734
735 }
736
PreCallValidateGetQueryPoolResults(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,size_t dataSize,void * pData,VkDeviceSize stride,VkQueryResultFlags flags) const737 bool ObjectLifetimes::PreCallValidateGetQueryPoolResults(
738 VkDevice device,
739 VkQueryPool queryPool,
740 uint32_t firstQuery,
741 uint32_t queryCount,
742 size_t dataSize,
743 void* pData,
744 VkDeviceSize stride,
745 VkQueryResultFlags flags) const {
746 bool skip = false;
747 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetQueryPoolResults-device-parameter", kVUIDUndefined);
748 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkGetQueryPoolResults-queryPool-parameter", "VUID-vkGetQueryPoolResults-queryPool-parent");
749
750 return skip;
751 }
752
PreCallValidateCreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer) const753 bool ObjectLifetimes::PreCallValidateCreateBuffer(
754 VkDevice device,
755 const VkBufferCreateInfo* pCreateInfo,
756 const VkAllocationCallbacks* pAllocator,
757 VkBuffer* pBuffer) const {
758 bool skip = false;
759 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateBuffer-device-parameter", kVUIDUndefined);
760
761 return skip;
762 }
763
PostCallRecordCreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer,VkResult result)764 void ObjectLifetimes::PostCallRecordCreateBuffer(
765 VkDevice device,
766 const VkBufferCreateInfo* pCreateInfo,
767 const VkAllocationCallbacks* pAllocator,
768 VkBuffer* pBuffer,
769 VkResult result) {
770 if (result != VK_SUCCESS) return;
771 CreateObject(*pBuffer, kVulkanObjectTypeBuffer, pAllocator);
772
773 }
774
PreCallValidateDestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator) const775 bool ObjectLifetimes::PreCallValidateDestroyBuffer(
776 VkDevice device,
777 VkBuffer buffer,
778 const VkAllocationCallbacks* pAllocator) const {
779 bool skip = false;
780 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyBuffer-device-parameter", kVUIDUndefined);
781 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, true, "VUID-vkDestroyBuffer-buffer-parameter", "VUID-vkDestroyBuffer-buffer-parent");
782 skip |= ValidateDestroyObject(buffer, kVulkanObjectTypeBuffer, pAllocator, "VUID-vkDestroyBuffer-buffer-00923", "VUID-vkDestroyBuffer-buffer-00924");
783
784 return skip;
785 }
786
PreCallRecordDestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator)787 void ObjectLifetimes::PreCallRecordDestroyBuffer(
788 VkDevice device,
789 VkBuffer buffer,
790 const VkAllocationCallbacks* pAllocator) {
791 RecordDestroyObject(buffer, kVulkanObjectTypeBuffer);
792
793 }
794
PreCallValidateCreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView) const795 bool ObjectLifetimes::PreCallValidateCreateBufferView(
796 VkDevice device,
797 const VkBufferViewCreateInfo* pCreateInfo,
798 const VkAllocationCallbacks* pAllocator,
799 VkBufferView* pView) const {
800 bool skip = false;
801 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateBufferView-device-parameter", kVUIDUndefined);
802 if (pCreateInfo) {
803 skip |= ValidateObject(pCreateInfo->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferViewCreateInfo-buffer-parameter", kVUIDUndefined);
804 }
805
806 return skip;
807 }
808
PostCallRecordCreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView,VkResult result)809 void ObjectLifetimes::PostCallRecordCreateBufferView(
810 VkDevice device,
811 const VkBufferViewCreateInfo* pCreateInfo,
812 const VkAllocationCallbacks* pAllocator,
813 VkBufferView* pView,
814 VkResult result) {
815 if (result != VK_SUCCESS) return;
816 CreateObject(*pView, kVulkanObjectTypeBufferView, pAllocator);
817
818 }
819
PreCallValidateDestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator) const820 bool ObjectLifetimes::PreCallValidateDestroyBufferView(
821 VkDevice device,
822 VkBufferView bufferView,
823 const VkAllocationCallbacks* pAllocator) const {
824 bool skip = false;
825 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyBufferView-device-parameter", kVUIDUndefined);
826 skip |= ValidateObject(bufferView, kVulkanObjectTypeBufferView, true, "VUID-vkDestroyBufferView-bufferView-parameter", "VUID-vkDestroyBufferView-bufferView-parent");
827 skip |= ValidateDestroyObject(bufferView, kVulkanObjectTypeBufferView, pAllocator, "VUID-vkDestroyBufferView-bufferView-00937", "VUID-vkDestroyBufferView-bufferView-00938");
828
829 return skip;
830 }
831
PreCallRecordDestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator)832 void ObjectLifetimes::PreCallRecordDestroyBufferView(
833 VkDevice device,
834 VkBufferView bufferView,
835 const VkAllocationCallbacks* pAllocator) {
836 RecordDestroyObject(bufferView, kVulkanObjectTypeBufferView);
837
838 }
839
PreCallValidateCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage) const840 bool ObjectLifetimes::PreCallValidateCreateImage(
841 VkDevice device,
842 const VkImageCreateInfo* pCreateInfo,
843 const VkAllocationCallbacks* pAllocator,
844 VkImage* pImage) const {
845 bool skip = false;
846 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateImage-device-parameter", kVUIDUndefined);
847
848 return skip;
849 }
850
PostCallRecordCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage,VkResult result)851 void ObjectLifetimes::PostCallRecordCreateImage(
852 VkDevice device,
853 const VkImageCreateInfo* pCreateInfo,
854 const VkAllocationCallbacks* pAllocator,
855 VkImage* pImage,
856 VkResult result) {
857 if (result != VK_SUCCESS) return;
858 CreateObject(*pImage, kVulkanObjectTypeImage, pAllocator);
859
860 }
861
PreCallValidateDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator) const862 bool ObjectLifetimes::PreCallValidateDestroyImage(
863 VkDevice device,
864 VkImage image,
865 const VkAllocationCallbacks* pAllocator) const {
866 bool skip = false;
867 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyImage-device-parameter", kVUIDUndefined);
868 skip |= ValidateObject(image, kVulkanObjectTypeImage, true, "VUID-vkDestroyImage-image-parameter", "VUID-vkDestroyImage-image-parent");
869 skip |= ValidateDestroyObject(image, kVulkanObjectTypeImage, pAllocator, "VUID-vkDestroyImage-image-01001", "VUID-vkDestroyImage-image-01002");
870
871 return skip;
872 }
873
PreCallRecordDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)874 void ObjectLifetimes::PreCallRecordDestroyImage(
875 VkDevice device,
876 VkImage image,
877 const VkAllocationCallbacks* pAllocator) {
878 RecordDestroyObject(image, kVulkanObjectTypeImage);
879
880 }
881
PreCallValidateGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout) const882 bool ObjectLifetimes::PreCallValidateGetImageSubresourceLayout(
883 VkDevice device,
884 VkImage image,
885 const VkImageSubresource* pSubresource,
886 VkSubresourceLayout* pLayout) const {
887 bool skip = false;
888 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSubresourceLayout-device-parameter", kVUIDUndefined);
889 skip |= ValidateObject(image, kVulkanObjectTypeImage, false, "VUID-vkGetImageSubresourceLayout-image-parameter", "VUID-vkGetImageSubresourceLayout-image-parent");
890
891 return skip;
892 }
893
PreCallValidateCreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView) const894 bool ObjectLifetimes::PreCallValidateCreateImageView(
895 VkDevice device,
896 const VkImageViewCreateInfo* pCreateInfo,
897 const VkAllocationCallbacks* pAllocator,
898 VkImageView* pView) const {
899 bool skip = false;
900 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateImageView-device-parameter", kVUIDUndefined);
901 if (pCreateInfo) {
902 skip |= ValidateObject(pCreateInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageViewCreateInfo-image-parameter", kVUIDUndefined);
903 }
904
905 return skip;
906 }
907
PostCallRecordCreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView,VkResult result)908 void ObjectLifetimes::PostCallRecordCreateImageView(
909 VkDevice device,
910 const VkImageViewCreateInfo* pCreateInfo,
911 const VkAllocationCallbacks* pAllocator,
912 VkImageView* pView,
913 VkResult result) {
914 if (result != VK_SUCCESS) return;
915 CreateObject(*pView, kVulkanObjectTypeImageView, pAllocator);
916
917 }
918
PreCallValidateDestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator) const919 bool ObjectLifetimes::PreCallValidateDestroyImageView(
920 VkDevice device,
921 VkImageView imageView,
922 const VkAllocationCallbacks* pAllocator) const {
923 bool skip = false;
924 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyImageView-device-parameter", kVUIDUndefined);
925 skip |= ValidateObject(imageView, kVulkanObjectTypeImageView, true, "VUID-vkDestroyImageView-imageView-parameter", "VUID-vkDestroyImageView-imageView-parent");
926 skip |= ValidateDestroyObject(imageView, kVulkanObjectTypeImageView, pAllocator, "VUID-vkDestroyImageView-imageView-01027", "VUID-vkDestroyImageView-imageView-01028");
927
928 return skip;
929 }
930
PreCallRecordDestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator)931 void ObjectLifetimes::PreCallRecordDestroyImageView(
932 VkDevice device,
933 VkImageView imageView,
934 const VkAllocationCallbacks* pAllocator) {
935 RecordDestroyObject(imageView, kVulkanObjectTypeImageView);
936
937 }
938
PreCallValidateCreateShaderModule(VkDevice device,const VkShaderModuleCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkShaderModule * pShaderModule) const939 bool ObjectLifetimes::PreCallValidateCreateShaderModule(
940 VkDevice device,
941 const VkShaderModuleCreateInfo* pCreateInfo,
942 const VkAllocationCallbacks* pAllocator,
943 VkShaderModule* pShaderModule) const {
944 bool skip = false;
945 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateShaderModule-device-parameter", kVUIDUndefined);
946
947 return skip;
948 }
949
PostCallRecordCreateShaderModule(VkDevice device,const VkShaderModuleCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkShaderModule * pShaderModule,VkResult result)950 void ObjectLifetimes::PostCallRecordCreateShaderModule(
951 VkDevice device,
952 const VkShaderModuleCreateInfo* pCreateInfo,
953 const VkAllocationCallbacks* pAllocator,
954 VkShaderModule* pShaderModule,
955 VkResult result) {
956 if (result != VK_SUCCESS) return;
957 CreateObject(*pShaderModule, kVulkanObjectTypeShaderModule, pAllocator);
958
959 }
960
PreCallValidateDestroyShaderModule(VkDevice device,VkShaderModule shaderModule,const VkAllocationCallbacks * pAllocator) const961 bool ObjectLifetimes::PreCallValidateDestroyShaderModule(
962 VkDevice device,
963 VkShaderModule shaderModule,
964 const VkAllocationCallbacks* pAllocator) const {
965 bool skip = false;
966 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyShaderModule-device-parameter", kVUIDUndefined);
967 skip |= ValidateObject(shaderModule, kVulkanObjectTypeShaderModule, true, "VUID-vkDestroyShaderModule-shaderModule-parameter", "VUID-vkDestroyShaderModule-shaderModule-parent");
968 skip |= ValidateDestroyObject(shaderModule, kVulkanObjectTypeShaderModule, pAllocator, "VUID-vkDestroyShaderModule-shaderModule-01092", "VUID-vkDestroyShaderModule-shaderModule-01093");
969
970 return skip;
971 }
972
PreCallRecordDestroyShaderModule(VkDevice device,VkShaderModule shaderModule,const VkAllocationCallbacks * pAllocator)973 void ObjectLifetimes::PreCallRecordDestroyShaderModule(
974 VkDevice device,
975 VkShaderModule shaderModule,
976 const VkAllocationCallbacks* pAllocator) {
977 RecordDestroyObject(shaderModule, kVulkanObjectTypeShaderModule);
978
979 }
980
PreCallValidateCreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache) const981 bool ObjectLifetimes::PreCallValidateCreatePipelineCache(
982 VkDevice device,
983 const VkPipelineCacheCreateInfo* pCreateInfo,
984 const VkAllocationCallbacks* pAllocator,
985 VkPipelineCache* pPipelineCache) const {
986 bool skip = false;
987 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreatePipelineCache-device-parameter", kVUIDUndefined);
988
989 return skip;
990 }
991
PostCallRecordCreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache,VkResult result)992 void ObjectLifetimes::PostCallRecordCreatePipelineCache(
993 VkDevice device,
994 const VkPipelineCacheCreateInfo* pCreateInfo,
995 const VkAllocationCallbacks* pAllocator,
996 VkPipelineCache* pPipelineCache,
997 VkResult result) {
998 if (result != VK_SUCCESS) return;
999 CreateObject(*pPipelineCache, kVulkanObjectTypePipelineCache, pAllocator);
1000
1001 }
1002
PreCallValidateDestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator) const1003 bool ObjectLifetimes::PreCallValidateDestroyPipelineCache(
1004 VkDevice device,
1005 VkPipelineCache pipelineCache,
1006 const VkAllocationCallbacks* pAllocator) const {
1007 bool skip = false;
1008 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyPipelineCache-device-parameter", kVUIDUndefined);
1009 skip |= ValidateObject(pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkDestroyPipelineCache-pipelineCache-parameter", "VUID-vkDestroyPipelineCache-pipelineCache-parent");
1010 skip |= ValidateDestroyObject(pipelineCache, kVulkanObjectTypePipelineCache, pAllocator, "VUID-vkDestroyPipelineCache-pipelineCache-00771", "VUID-vkDestroyPipelineCache-pipelineCache-00772");
1011
1012 return skip;
1013 }
1014
PreCallRecordDestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator)1015 void ObjectLifetimes::PreCallRecordDestroyPipelineCache(
1016 VkDevice device,
1017 VkPipelineCache pipelineCache,
1018 const VkAllocationCallbacks* pAllocator) {
1019 RecordDestroyObject(pipelineCache, kVulkanObjectTypePipelineCache);
1020
1021 }
1022
PreCallValidateGetPipelineCacheData(VkDevice device,VkPipelineCache pipelineCache,size_t * pDataSize,void * pData) const1023 bool ObjectLifetimes::PreCallValidateGetPipelineCacheData(
1024 VkDevice device,
1025 VkPipelineCache pipelineCache,
1026 size_t* pDataSize,
1027 void* pData) const {
1028 bool skip = false;
1029 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineCacheData-device-parameter", kVUIDUndefined);
1030 skip |= ValidateObject(pipelineCache, kVulkanObjectTypePipelineCache, false, "VUID-vkGetPipelineCacheData-pipelineCache-parameter", "VUID-vkGetPipelineCacheData-pipelineCache-parent");
1031
1032 return skip;
1033 }
1034
PreCallValidateMergePipelineCaches(VkDevice device,VkPipelineCache dstCache,uint32_t srcCacheCount,const VkPipelineCache * pSrcCaches) const1035 bool ObjectLifetimes::PreCallValidateMergePipelineCaches(
1036 VkDevice device,
1037 VkPipelineCache dstCache,
1038 uint32_t srcCacheCount,
1039 const VkPipelineCache* pSrcCaches) const {
1040 bool skip = false;
1041 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkMergePipelineCaches-device-parameter", kVUIDUndefined);
1042 skip |= ValidateObject(dstCache, kVulkanObjectTypePipelineCache, false, "VUID-vkMergePipelineCaches-dstCache-parameter", "VUID-vkMergePipelineCaches-dstCache-parent");
1043 if (pSrcCaches) {
1044 for (uint32_t index0 = 0; index0 < srcCacheCount; ++index0) {
1045 skip |= ValidateObject(pSrcCaches[index0], kVulkanObjectTypePipelineCache, false, "VUID-vkMergePipelineCaches-pSrcCaches-parameter", "VUID-vkMergePipelineCaches-pSrcCaches-parent");
1046 }
1047 }
1048
1049 return skip;
1050 }
1051
PreCallValidateCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const1052 bool ObjectLifetimes::PreCallValidateCreateGraphicsPipelines(
1053 VkDevice device,
1054 VkPipelineCache pipelineCache,
1055 uint32_t createInfoCount,
1056 const VkGraphicsPipelineCreateInfo* pCreateInfos,
1057 const VkAllocationCallbacks* pAllocator,
1058 VkPipeline* pPipelines) const {
1059 bool skip = false;
1060 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateGraphicsPipelines-device-parameter", kVUIDUndefined);
1061 skip |= ValidateObject(pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateGraphicsPipelines-pipelineCache-parameter", "VUID-vkCreateGraphicsPipelines-pipelineCache-parent");
1062 if (pCreateInfos) {
1063 for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
1064 if (pCreateInfos[index0].pStages) {
1065 for (uint32_t index1 = 0; index1 < pCreateInfos[index0].stageCount; ++index1) {
1066 skip |= ValidateObject(pCreateInfos[index0].pStages[index1].module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
1067 }
1068 }
1069 skip |= ValidateObject(pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkGraphicsPipelineCreateInfo-layout-parameter", "VUID-VkGraphicsPipelineCreateInfo-commonparent");
1070 skip |= ValidateObject(pCreateInfos[index0].renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter", "VUID-VkGraphicsPipelineCreateInfo-commonparent");
1071 if ((pCreateInfos[index0].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) && (pCreateInfos[index0].basePipelineIndex == -1))
1072 skip |= ValidateObject(pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, false, "VUID-VkGraphicsPipelineCreateInfo-flags-00722", "VUID-VkGraphicsPipelineCreateInfo-commonparent");
1073 }
1074 }
1075
1076 return skip;
1077 }
1078
PostCallRecordCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,VkResult result)1079 void ObjectLifetimes::PostCallRecordCreateGraphicsPipelines(
1080 VkDevice device,
1081 VkPipelineCache pipelineCache,
1082 uint32_t createInfoCount,
1083 const VkGraphicsPipelineCreateInfo* pCreateInfos,
1084 const VkAllocationCallbacks* pAllocator,
1085 VkPipeline* pPipelines,
1086 VkResult result) {
1087 if (VK_ERROR_VALIDATION_FAILED_EXT == result) return;
1088 if (pPipelines) {
1089 for (uint32_t index = 0; index < createInfoCount; index++) {
1090 if (!pPipelines[index]) continue;
1091 CreateObject(pPipelines[index], kVulkanObjectTypePipeline, pAllocator);
1092 }
1093 }
1094
1095 }
1096
PreCallValidateCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const1097 bool ObjectLifetimes::PreCallValidateCreateComputePipelines(
1098 VkDevice device,
1099 VkPipelineCache pipelineCache,
1100 uint32_t createInfoCount,
1101 const VkComputePipelineCreateInfo* pCreateInfos,
1102 const VkAllocationCallbacks* pAllocator,
1103 VkPipeline* pPipelines) const {
1104 bool skip = false;
1105 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateComputePipelines-device-parameter", kVUIDUndefined);
1106 skip |= ValidateObject(pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateComputePipelines-pipelineCache-parameter", "VUID-vkCreateComputePipelines-pipelineCache-parent");
1107 if (pCreateInfos) {
1108 for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
1109 skip |= ValidateObject(pCreateInfos[index0].stage.module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
1110 skip |= ValidateObject(pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkComputePipelineCreateInfo-layout-parameter", "VUID-VkComputePipelineCreateInfo-commonparent");
1111 if ((pCreateInfos[index0].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) && (pCreateInfos[index0].basePipelineIndex == -1))
1112 skip |= ValidateObject(pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, false, "VUID-VkComputePipelineCreateInfo-flags-00697", "VUID-VkComputePipelineCreateInfo-commonparent");
1113 }
1114 }
1115
1116 return skip;
1117 }
1118
PostCallRecordCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,VkResult result)1119 void ObjectLifetimes::PostCallRecordCreateComputePipelines(
1120 VkDevice device,
1121 VkPipelineCache pipelineCache,
1122 uint32_t createInfoCount,
1123 const VkComputePipelineCreateInfo* pCreateInfos,
1124 const VkAllocationCallbacks* pAllocator,
1125 VkPipeline* pPipelines,
1126 VkResult result) {
1127 if (VK_ERROR_VALIDATION_FAILED_EXT == result) return;
1128 if (pPipelines) {
1129 for (uint32_t index = 0; index < createInfoCount; index++) {
1130 if (!pPipelines[index]) continue;
1131 CreateObject(pPipelines[index], kVulkanObjectTypePipeline, pAllocator);
1132 }
1133 }
1134
1135 }
1136
PreCallValidateDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator) const1137 bool ObjectLifetimes::PreCallValidateDestroyPipeline(
1138 VkDevice device,
1139 VkPipeline pipeline,
1140 const VkAllocationCallbacks* pAllocator) const {
1141 bool skip = false;
1142 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyPipeline-device-parameter", kVUIDUndefined);
1143 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, true, "VUID-vkDestroyPipeline-pipeline-parameter", "VUID-vkDestroyPipeline-pipeline-parent");
1144 skip |= ValidateDestroyObject(pipeline, kVulkanObjectTypePipeline, pAllocator, "VUID-vkDestroyPipeline-pipeline-00766", "VUID-vkDestroyPipeline-pipeline-00767");
1145
1146 return skip;
1147 }
1148
PreCallRecordDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)1149 void ObjectLifetimes::PreCallRecordDestroyPipeline(
1150 VkDevice device,
1151 VkPipeline pipeline,
1152 const VkAllocationCallbacks* pAllocator) {
1153 RecordDestroyObject(pipeline, kVulkanObjectTypePipeline);
1154
1155 }
1156
PreCallValidateCreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout) const1157 bool ObjectLifetimes::PreCallValidateCreatePipelineLayout(
1158 VkDevice device,
1159 const VkPipelineLayoutCreateInfo* pCreateInfo,
1160 const VkAllocationCallbacks* pAllocator,
1161 VkPipelineLayout* pPipelineLayout) const {
1162 bool skip = false;
1163 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreatePipelineLayout-device-parameter", kVUIDUndefined);
1164 if (pCreateInfo) {
1165 if (pCreateInfo->pSetLayouts) {
1166 for (uint32_t index1 = 0; index1 < pCreateInfo->setLayoutCount; ++index1) {
1167 skip |= ValidateObject(pCreateInfo->pSetLayouts[index1], kVulkanObjectTypeDescriptorSetLayout, false, "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined);
1168 }
1169 }
1170 }
1171
1172 return skip;
1173 }
1174
PostCallRecordCreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout,VkResult result)1175 void ObjectLifetimes::PostCallRecordCreatePipelineLayout(
1176 VkDevice device,
1177 const VkPipelineLayoutCreateInfo* pCreateInfo,
1178 const VkAllocationCallbacks* pAllocator,
1179 VkPipelineLayout* pPipelineLayout,
1180 VkResult result) {
1181 if (result != VK_SUCCESS) return;
1182 CreateObject(*pPipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator);
1183
1184 }
1185
PreCallValidateDestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator) const1186 bool ObjectLifetimes::PreCallValidateDestroyPipelineLayout(
1187 VkDevice device,
1188 VkPipelineLayout pipelineLayout,
1189 const VkAllocationCallbacks* pAllocator) const {
1190 bool skip = false;
1191 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyPipelineLayout-device-parameter", kVUIDUndefined);
1192 skip |= ValidateObject(pipelineLayout, kVulkanObjectTypePipelineLayout, true, "VUID-vkDestroyPipelineLayout-pipelineLayout-parameter", "VUID-vkDestroyPipelineLayout-pipelineLayout-parent");
1193 skip |= ValidateDestroyObject(pipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator, "VUID-vkDestroyPipelineLayout-pipelineLayout-00299", "VUID-vkDestroyPipelineLayout-pipelineLayout-00300");
1194
1195 return skip;
1196 }
1197
PreCallRecordDestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator)1198 void ObjectLifetimes::PreCallRecordDestroyPipelineLayout(
1199 VkDevice device,
1200 VkPipelineLayout pipelineLayout,
1201 const VkAllocationCallbacks* pAllocator) {
1202 RecordDestroyObject(pipelineLayout, kVulkanObjectTypePipelineLayout);
1203
1204 }
1205
PreCallValidateCreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler) const1206 bool ObjectLifetimes::PreCallValidateCreateSampler(
1207 VkDevice device,
1208 const VkSamplerCreateInfo* pCreateInfo,
1209 const VkAllocationCallbacks* pAllocator,
1210 VkSampler* pSampler) const {
1211 bool skip = false;
1212 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSampler-device-parameter", kVUIDUndefined);
1213
1214 return skip;
1215 }
1216
PostCallRecordCreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler,VkResult result)1217 void ObjectLifetimes::PostCallRecordCreateSampler(
1218 VkDevice device,
1219 const VkSamplerCreateInfo* pCreateInfo,
1220 const VkAllocationCallbacks* pAllocator,
1221 VkSampler* pSampler,
1222 VkResult result) {
1223 if (result != VK_SUCCESS) return;
1224 CreateObject(*pSampler, kVulkanObjectTypeSampler, pAllocator);
1225
1226 }
1227
PreCallValidateDestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator) const1228 bool ObjectLifetimes::PreCallValidateDestroySampler(
1229 VkDevice device,
1230 VkSampler sampler,
1231 const VkAllocationCallbacks* pAllocator) const {
1232 bool skip = false;
1233 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySampler-device-parameter", kVUIDUndefined);
1234 skip |= ValidateObject(sampler, kVulkanObjectTypeSampler, true, "VUID-vkDestroySampler-sampler-parameter", "VUID-vkDestroySampler-sampler-parent");
1235 skip |= ValidateDestroyObject(sampler, kVulkanObjectTypeSampler, pAllocator, "VUID-vkDestroySampler-sampler-01083", "VUID-vkDestroySampler-sampler-01084");
1236
1237 return skip;
1238 }
1239
PreCallRecordDestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator)1240 void ObjectLifetimes::PreCallRecordDestroySampler(
1241 VkDevice device,
1242 VkSampler sampler,
1243 const VkAllocationCallbacks* pAllocator) {
1244 RecordDestroyObject(sampler, kVulkanObjectTypeSampler);
1245
1246 }
1247
PreCallValidateDestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator) const1248 bool ObjectLifetimes::PreCallValidateDestroyDescriptorSetLayout(
1249 VkDevice device,
1250 VkDescriptorSetLayout descriptorSetLayout,
1251 const VkAllocationCallbacks* pAllocator) const {
1252 bool skip = false;
1253 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorSetLayout-device-parameter", kVUIDUndefined);
1254 skip |= ValidateObject(descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter", "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent");
1255 skip |= ValidateDestroyObject(descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator, "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284", "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285");
1256
1257 return skip;
1258 }
1259
PreCallRecordDestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator)1260 void ObjectLifetimes::PreCallRecordDestroyDescriptorSetLayout(
1261 VkDevice device,
1262 VkDescriptorSetLayout descriptorSetLayout,
1263 const VkAllocationCallbacks* pAllocator) {
1264 RecordDestroyObject(descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout);
1265
1266 }
1267
PreCallValidateCreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool) const1268 bool ObjectLifetimes::PreCallValidateCreateDescriptorPool(
1269 VkDevice device,
1270 const VkDescriptorPoolCreateInfo* pCreateInfo,
1271 const VkAllocationCallbacks* pAllocator,
1272 VkDescriptorPool* pDescriptorPool) const {
1273 bool skip = false;
1274 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateDescriptorPool-device-parameter", kVUIDUndefined);
1275
1276 return skip;
1277 }
1278
PostCallRecordCreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool,VkResult result)1279 void ObjectLifetimes::PostCallRecordCreateDescriptorPool(
1280 VkDevice device,
1281 const VkDescriptorPoolCreateInfo* pCreateInfo,
1282 const VkAllocationCallbacks* pAllocator,
1283 VkDescriptorPool* pDescriptorPool,
1284 VkResult result) {
1285 if (result != VK_SUCCESS) return;
1286 CreateObject(*pDescriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator);
1287
1288 }
1289
PreCallValidateDestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator) const1290 bool ObjectLifetimes::PreCallValidateDestroyFramebuffer(
1291 VkDevice device,
1292 VkFramebuffer framebuffer,
1293 const VkAllocationCallbacks* pAllocator) const {
1294 bool skip = false;
1295 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyFramebuffer-device-parameter", kVUIDUndefined);
1296 skip |= ValidateObject(framebuffer, kVulkanObjectTypeFramebuffer, true, "VUID-vkDestroyFramebuffer-framebuffer-parameter", "VUID-vkDestroyFramebuffer-framebuffer-parent");
1297 skip |= ValidateDestroyObject(framebuffer, kVulkanObjectTypeFramebuffer, pAllocator, "VUID-vkDestroyFramebuffer-framebuffer-00893", "VUID-vkDestroyFramebuffer-framebuffer-00894");
1298
1299 return skip;
1300 }
1301
PreCallRecordDestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator)1302 void ObjectLifetimes::PreCallRecordDestroyFramebuffer(
1303 VkDevice device,
1304 VkFramebuffer framebuffer,
1305 const VkAllocationCallbacks* pAllocator) {
1306 RecordDestroyObject(framebuffer, kVulkanObjectTypeFramebuffer);
1307
1308 }
1309
PreCallValidateCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const1310 bool ObjectLifetimes::PreCallValidateCreateRenderPass(
1311 VkDevice device,
1312 const VkRenderPassCreateInfo* pCreateInfo,
1313 const VkAllocationCallbacks* pAllocator,
1314 VkRenderPass* pRenderPass) const {
1315 bool skip = false;
1316 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRenderPass-device-parameter", kVUIDUndefined);
1317
1318 return skip;
1319 }
1320
PostCallRecordCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass,VkResult result)1321 void ObjectLifetimes::PostCallRecordCreateRenderPass(
1322 VkDevice device,
1323 const VkRenderPassCreateInfo* pCreateInfo,
1324 const VkAllocationCallbacks* pAllocator,
1325 VkRenderPass* pRenderPass,
1326 VkResult result) {
1327 if (result != VK_SUCCESS) return;
1328 CreateObject(*pRenderPass, kVulkanObjectTypeRenderPass, pAllocator);
1329
1330 }
1331
PreCallValidateDestroyRenderPass(VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator) const1332 bool ObjectLifetimes::PreCallValidateDestroyRenderPass(
1333 VkDevice device,
1334 VkRenderPass renderPass,
1335 const VkAllocationCallbacks* pAllocator) const {
1336 bool skip = false;
1337 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyRenderPass-device-parameter", kVUIDUndefined);
1338 skip |= ValidateObject(renderPass, kVulkanObjectTypeRenderPass, true, "VUID-vkDestroyRenderPass-renderPass-parameter", "VUID-vkDestroyRenderPass-renderPass-parent");
1339 skip |= ValidateDestroyObject(renderPass, kVulkanObjectTypeRenderPass, pAllocator, "VUID-vkDestroyRenderPass-renderPass-00874", "VUID-vkDestroyRenderPass-renderPass-00875");
1340
1341 return skip;
1342 }
1343
PreCallRecordDestroyRenderPass(VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1344 void ObjectLifetimes::PreCallRecordDestroyRenderPass(
1345 VkDevice device,
1346 VkRenderPass renderPass,
1347 const VkAllocationCallbacks* pAllocator) {
1348 RecordDestroyObject(renderPass, kVulkanObjectTypeRenderPass);
1349
1350 }
1351
PreCallValidateGetRenderAreaGranularity(VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity) const1352 bool ObjectLifetimes::PreCallValidateGetRenderAreaGranularity(
1353 VkDevice device,
1354 VkRenderPass renderPass,
1355 VkExtent2D* pGranularity) const {
1356 bool skip = false;
1357 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetRenderAreaGranularity-device-parameter", kVUIDUndefined);
1358 skip |= ValidateObject(renderPass, kVulkanObjectTypeRenderPass, false, "VUID-vkGetRenderAreaGranularity-renderPass-parameter", "VUID-vkGetRenderAreaGranularity-renderPass-parent");
1359
1360 return skip;
1361 }
1362
PreCallValidateCreateCommandPool(VkDevice device,const VkCommandPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkCommandPool * pCommandPool) const1363 bool ObjectLifetimes::PreCallValidateCreateCommandPool(
1364 VkDevice device,
1365 const VkCommandPoolCreateInfo* pCreateInfo,
1366 const VkAllocationCallbacks* pAllocator,
1367 VkCommandPool* pCommandPool) const {
1368 bool skip = false;
1369 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateCommandPool-device-parameter", kVUIDUndefined);
1370
1371 return skip;
1372 }
1373
PostCallRecordCreateCommandPool(VkDevice device,const VkCommandPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkCommandPool * pCommandPool,VkResult result)1374 void ObjectLifetimes::PostCallRecordCreateCommandPool(
1375 VkDevice device,
1376 const VkCommandPoolCreateInfo* pCreateInfo,
1377 const VkAllocationCallbacks* pAllocator,
1378 VkCommandPool* pCommandPool,
1379 VkResult result) {
1380 if (result != VK_SUCCESS) return;
1381 CreateObject(*pCommandPool, kVulkanObjectTypeCommandPool, pAllocator);
1382
1383 }
1384
PreCallValidateResetCommandPool(VkDevice device,VkCommandPool commandPool,VkCommandPoolResetFlags flags) const1385 bool ObjectLifetimes::PreCallValidateResetCommandPool(
1386 VkDevice device,
1387 VkCommandPool commandPool,
1388 VkCommandPoolResetFlags flags) const {
1389 bool skip = false;
1390 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkResetCommandPool-device-parameter", kVUIDUndefined);
1391 skip |= ValidateObject(commandPool, kVulkanObjectTypeCommandPool, false, "VUID-vkResetCommandPool-commandPool-parameter", "VUID-vkResetCommandPool-commandPool-parent");
1392
1393 return skip;
1394 }
1395
PreCallValidateEndCommandBuffer(VkCommandBuffer commandBuffer) const1396 bool ObjectLifetimes::PreCallValidateEndCommandBuffer(
1397 VkCommandBuffer commandBuffer) const {
1398 bool skip = false;
1399 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkEndCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
1400
1401 return skip;
1402 }
1403
PreCallValidateResetCommandBuffer(VkCommandBuffer commandBuffer,VkCommandBufferResetFlags flags) const1404 bool ObjectLifetimes::PreCallValidateResetCommandBuffer(
1405 VkCommandBuffer commandBuffer,
1406 VkCommandBufferResetFlags flags) const {
1407 bool skip = false;
1408 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkResetCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
1409
1410 return skip;
1411 }
1412
PreCallValidateCmdBindPipeline(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipeline pipeline) const1413 bool ObjectLifetimes::PreCallValidateCmdBindPipeline(
1414 VkCommandBuffer commandBuffer,
1415 VkPipelineBindPoint pipelineBindPoint,
1416 VkPipeline pipeline) const {
1417 bool skip = false;
1418 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindPipeline-commandBuffer-parameter", "VUID-vkCmdBindPipeline-commonparent");
1419 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, false, "VUID-vkCmdBindPipeline-pipeline-parameter", "VUID-vkCmdBindPipeline-commonparent");
1420
1421 return skip;
1422 }
1423
PreCallValidateCmdSetViewport(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkViewport * pViewports) const1424 bool ObjectLifetimes::PreCallValidateCmdSetViewport(
1425 VkCommandBuffer commandBuffer,
1426 uint32_t firstViewport,
1427 uint32_t viewportCount,
1428 const VkViewport* pViewports) const {
1429 bool skip = false;
1430 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetViewport-commandBuffer-parameter", kVUIDUndefined);
1431
1432 return skip;
1433 }
1434
PreCallValidateCmdSetScissor(VkCommandBuffer commandBuffer,uint32_t firstScissor,uint32_t scissorCount,const VkRect2D * pScissors) const1435 bool ObjectLifetimes::PreCallValidateCmdSetScissor(
1436 VkCommandBuffer commandBuffer,
1437 uint32_t firstScissor,
1438 uint32_t scissorCount,
1439 const VkRect2D* pScissors) const {
1440 bool skip = false;
1441 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetScissor-commandBuffer-parameter", kVUIDUndefined);
1442
1443 return skip;
1444 }
1445
PreCallValidateCmdSetLineWidth(VkCommandBuffer commandBuffer,float lineWidth) const1446 bool ObjectLifetimes::PreCallValidateCmdSetLineWidth(
1447 VkCommandBuffer commandBuffer,
1448 float lineWidth) const {
1449 bool skip = false;
1450 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetLineWidth-commandBuffer-parameter", kVUIDUndefined);
1451
1452 return skip;
1453 }
1454
PreCallValidateCmdSetDepthBias(VkCommandBuffer commandBuffer,float depthBiasConstantFactor,float depthBiasClamp,float depthBiasSlopeFactor) const1455 bool ObjectLifetimes::PreCallValidateCmdSetDepthBias(
1456 VkCommandBuffer commandBuffer,
1457 float depthBiasConstantFactor,
1458 float depthBiasClamp,
1459 float depthBiasSlopeFactor) const {
1460 bool skip = false;
1461 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthBias-commandBuffer-parameter", kVUIDUndefined);
1462
1463 return skip;
1464 }
1465
PreCallValidateCmdSetBlendConstants(VkCommandBuffer commandBuffer,const float blendConstants[4]) const1466 bool ObjectLifetimes::PreCallValidateCmdSetBlendConstants(
1467 VkCommandBuffer commandBuffer,
1468 const float blendConstants[4]) const {
1469 bool skip = false;
1470 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetBlendConstants-commandBuffer-parameter", kVUIDUndefined);
1471
1472 return skip;
1473 }
1474
PreCallValidateCmdSetDepthBounds(VkCommandBuffer commandBuffer,float minDepthBounds,float maxDepthBounds) const1475 bool ObjectLifetimes::PreCallValidateCmdSetDepthBounds(
1476 VkCommandBuffer commandBuffer,
1477 float minDepthBounds,
1478 float maxDepthBounds) const {
1479 bool skip = false;
1480 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthBounds-commandBuffer-parameter", kVUIDUndefined);
1481
1482 return skip;
1483 }
1484
PreCallValidateCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t compareMask) const1485 bool ObjectLifetimes::PreCallValidateCmdSetStencilCompareMask(
1486 VkCommandBuffer commandBuffer,
1487 VkStencilFaceFlags faceMask,
1488 uint32_t compareMask) const {
1489 bool skip = false;
1490 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter", kVUIDUndefined);
1491
1492 return skip;
1493 }
1494
PreCallValidateCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t writeMask) const1495 bool ObjectLifetimes::PreCallValidateCmdSetStencilWriteMask(
1496 VkCommandBuffer commandBuffer,
1497 VkStencilFaceFlags faceMask,
1498 uint32_t writeMask) const {
1499 bool skip = false;
1500 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter", kVUIDUndefined);
1501
1502 return skip;
1503 }
1504
PreCallValidateCmdSetStencilReference(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t reference) const1505 bool ObjectLifetimes::PreCallValidateCmdSetStencilReference(
1506 VkCommandBuffer commandBuffer,
1507 VkStencilFaceFlags faceMask,
1508 uint32_t reference) const {
1509 bool skip = false;
1510 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilReference-commandBuffer-parameter", kVUIDUndefined);
1511
1512 return skip;
1513 }
1514
PreCallValidateCmdBindDescriptorSets(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipelineLayout layout,uint32_t firstSet,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets,uint32_t dynamicOffsetCount,const uint32_t * pDynamicOffsets) const1515 bool ObjectLifetimes::PreCallValidateCmdBindDescriptorSets(
1516 VkCommandBuffer commandBuffer,
1517 VkPipelineBindPoint pipelineBindPoint,
1518 VkPipelineLayout layout,
1519 uint32_t firstSet,
1520 uint32_t descriptorSetCount,
1521 const VkDescriptorSet* pDescriptorSets,
1522 uint32_t dynamicOffsetCount,
1523 const uint32_t* pDynamicOffsets) const {
1524 bool skip = false;
1525 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindDescriptorSets-commandBuffer-parameter", "VUID-vkCmdBindDescriptorSets-commonparent");
1526 skip |= ValidateObject(layout, kVulkanObjectTypePipelineLayout, false, "VUID-vkCmdBindDescriptorSets-layout-parameter", "VUID-vkCmdBindDescriptorSets-commonparent");
1527 if (pDescriptorSets) {
1528 for (uint32_t index0 = 0; index0 < descriptorSetCount; ++index0) {
1529 skip |= ValidateObject(pDescriptorSets[index0], kVulkanObjectTypeDescriptorSet, false, "VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter", "VUID-vkCmdBindDescriptorSets-commonparent");
1530 }
1531 }
1532
1533 return skip;
1534 }
1535
PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkIndexType indexType) const1536 bool ObjectLifetimes::PreCallValidateCmdBindIndexBuffer(
1537 VkCommandBuffer commandBuffer,
1538 VkBuffer buffer,
1539 VkDeviceSize offset,
1540 VkIndexType indexType) const {
1541 bool skip = false;
1542 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindIndexBuffer-commandBuffer-parameter", "VUID-vkCmdBindIndexBuffer-commonparent");
1543 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindIndexBuffer-buffer-parameter", "VUID-vkCmdBindIndexBuffer-commonparent");
1544
1545 return skip;
1546 }
1547
PreCallValidateCmdBindVertexBuffers(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets) const1548 bool ObjectLifetimes::PreCallValidateCmdBindVertexBuffers(
1549 VkCommandBuffer commandBuffer,
1550 uint32_t firstBinding,
1551 uint32_t bindingCount,
1552 const VkBuffer* pBuffers,
1553 const VkDeviceSize* pOffsets) const {
1554 bool skip = false;
1555 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindVertexBuffers-commandBuffer-parameter", "VUID-vkCmdBindVertexBuffers-commonparent");
1556 if (pBuffers) {
1557 for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
1558 skip |= ValidateObject(pBuffers[index0], kVulkanObjectTypeBuffer, true, "VUID-vkCmdBindVertexBuffers-pBuffers-parameter", "VUID-vkCmdBindVertexBuffers-commonparent");
1559 }
1560 }
1561
1562 return skip;
1563 }
1564
PreCallValidateCmdDraw(VkCommandBuffer commandBuffer,uint32_t vertexCount,uint32_t instanceCount,uint32_t firstVertex,uint32_t firstInstance) const1565 bool ObjectLifetimes::PreCallValidateCmdDraw(
1566 VkCommandBuffer commandBuffer,
1567 uint32_t vertexCount,
1568 uint32_t instanceCount,
1569 uint32_t firstVertex,
1570 uint32_t firstInstance) const {
1571 bool skip = false;
1572 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDraw-commandBuffer-parameter", kVUIDUndefined);
1573
1574 return skip;
1575 }
1576
PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer,uint32_t indexCount,uint32_t instanceCount,uint32_t firstIndex,int32_t vertexOffset,uint32_t firstInstance) const1577 bool ObjectLifetimes::PreCallValidateCmdDrawIndexed(
1578 VkCommandBuffer commandBuffer,
1579 uint32_t indexCount,
1580 uint32_t instanceCount,
1581 uint32_t firstIndex,
1582 int32_t vertexOffset,
1583 uint32_t firstInstance) const {
1584 bool skip = false;
1585 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexed-commandBuffer-parameter", kVUIDUndefined);
1586
1587 return skip;
1588 }
1589
PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const1590 bool ObjectLifetimes::PreCallValidateCmdDrawIndirect(
1591 VkCommandBuffer commandBuffer,
1592 VkBuffer buffer,
1593 VkDeviceSize offset,
1594 uint32_t drawCount,
1595 uint32_t stride) const {
1596 bool skip = false;
1597 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirect-commandBuffer-parameter", "VUID-vkCmdDrawIndirect-commonparent");
1598 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirect-buffer-parameter", "VUID-vkCmdDrawIndirect-commonparent");
1599
1600 return skip;
1601 }
1602
PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const1603 bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirect(
1604 VkCommandBuffer commandBuffer,
1605 VkBuffer buffer,
1606 VkDeviceSize offset,
1607 uint32_t drawCount,
1608 uint32_t stride) const {
1609 bool skip = false;
1610 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter", "VUID-vkCmdDrawIndexedIndirect-commonparent");
1611 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirect-buffer-parameter", "VUID-vkCmdDrawIndexedIndirect-commonparent");
1612
1613 return skip;
1614 }
1615
PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const1616 bool ObjectLifetimes::PreCallValidateCmdDispatch(
1617 VkCommandBuffer commandBuffer,
1618 uint32_t groupCountX,
1619 uint32_t groupCountY,
1620 uint32_t groupCountZ) const {
1621 bool skip = false;
1622 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatch-commandBuffer-parameter", kVUIDUndefined);
1623
1624 return skip;
1625 }
1626
PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset) const1627 bool ObjectLifetimes::PreCallValidateCmdDispatchIndirect(
1628 VkCommandBuffer commandBuffer,
1629 VkBuffer buffer,
1630 VkDeviceSize offset) const {
1631 bool skip = false;
1632 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatchIndirect-commandBuffer-parameter", "VUID-vkCmdDispatchIndirect-commonparent");
1633 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDispatchIndirect-buffer-parameter", "VUID-vkCmdDispatchIndirect-commonparent");
1634
1635 return skip;
1636 }
1637
PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferCopy * pRegions) const1638 bool ObjectLifetimes::PreCallValidateCmdCopyBuffer(
1639 VkCommandBuffer commandBuffer,
1640 VkBuffer srcBuffer,
1641 VkBuffer dstBuffer,
1642 uint32_t regionCount,
1643 const VkBufferCopy* pRegions) const {
1644 bool skip = false;
1645 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyBuffer-commandBuffer-parameter", "VUID-vkCmdCopyBuffer-commonparent");
1646 skip |= ValidateObject(srcBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyBuffer-srcBuffer-parameter", "VUID-vkCmdCopyBuffer-commonparent");
1647 skip |= ValidateObject(dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyBuffer-dstBuffer-parameter", "VUID-vkCmdCopyBuffer-commonparent");
1648
1649 return skip;
1650 }
1651
PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageCopy * pRegions) const1652 bool ObjectLifetimes::PreCallValidateCmdCopyImage(
1653 VkCommandBuffer commandBuffer,
1654 VkImage srcImage,
1655 VkImageLayout srcImageLayout,
1656 VkImage dstImage,
1657 VkImageLayout dstImageLayout,
1658 uint32_t regionCount,
1659 const VkImageCopy* pRegions) const {
1660 bool skip = false;
1661 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyImage-commandBuffer-parameter", "VUID-vkCmdCopyImage-commonparent");
1662 skip |= ValidateObject(srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyImage-srcImage-parameter", "VUID-vkCmdCopyImage-commonparent");
1663 skip |= ValidateObject(dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyImage-dstImage-parameter", "VUID-vkCmdCopyImage-commonparent");
1664
1665 return skip;
1666 }
1667
PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageBlit * pRegions,VkFilter filter) const1668 bool ObjectLifetimes::PreCallValidateCmdBlitImage(
1669 VkCommandBuffer commandBuffer,
1670 VkImage srcImage,
1671 VkImageLayout srcImageLayout,
1672 VkImage dstImage,
1673 VkImageLayout dstImageLayout,
1674 uint32_t regionCount,
1675 const VkImageBlit* pRegions,
1676 VkFilter filter) const {
1677 bool skip = false;
1678 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBlitImage-commandBuffer-parameter", "VUID-vkCmdBlitImage-commonparent");
1679 skip |= ValidateObject(srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdBlitImage-srcImage-parameter", "VUID-vkCmdBlitImage-commonparent");
1680 skip |= ValidateObject(dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdBlitImage-dstImage-parameter", "VUID-vkCmdBlitImage-commonparent");
1681
1682 return skip;
1683 }
1684
PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkBufferImageCopy * pRegions) const1685 bool ObjectLifetimes::PreCallValidateCmdCopyBufferToImage(
1686 VkCommandBuffer commandBuffer,
1687 VkBuffer srcBuffer,
1688 VkImage dstImage,
1689 VkImageLayout dstImageLayout,
1690 uint32_t regionCount,
1691 const VkBufferImageCopy* pRegions) const {
1692 bool skip = false;
1693 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyBufferToImage-commandBuffer-parameter", "VUID-vkCmdCopyBufferToImage-commonparent");
1694 skip |= ValidateObject(srcBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyBufferToImage-srcBuffer-parameter", "VUID-vkCmdCopyBufferToImage-commonparent");
1695 skip |= ValidateObject(dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyBufferToImage-dstImage-parameter", "VUID-vkCmdCopyBufferToImage-commonparent");
1696
1697 return skip;
1698 }
1699
PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferImageCopy * pRegions) const1700 bool ObjectLifetimes::PreCallValidateCmdCopyImageToBuffer(
1701 VkCommandBuffer commandBuffer,
1702 VkImage srcImage,
1703 VkImageLayout srcImageLayout,
1704 VkBuffer dstBuffer,
1705 uint32_t regionCount,
1706 const VkBufferImageCopy* pRegions) const {
1707 bool skip = false;
1708 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter", "VUID-vkCmdCopyImageToBuffer-commonparent");
1709 skip |= ValidateObject(srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyImageToBuffer-srcImage-parameter", "VUID-vkCmdCopyImageToBuffer-commonparent");
1710 skip |= ValidateObject(dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter", "VUID-vkCmdCopyImageToBuffer-commonparent");
1711
1712 return skip;
1713 }
1714
PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize dataSize,const void * pData) const1715 bool ObjectLifetimes::PreCallValidateCmdUpdateBuffer(
1716 VkCommandBuffer commandBuffer,
1717 VkBuffer dstBuffer,
1718 VkDeviceSize dstOffset,
1719 VkDeviceSize dataSize,
1720 const void* pData) const {
1721 bool skip = false;
1722 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdUpdateBuffer-commandBuffer-parameter", "VUID-vkCmdUpdateBuffer-commonparent");
1723 skip |= ValidateObject(dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdUpdateBuffer-dstBuffer-parameter", "VUID-vkCmdUpdateBuffer-commonparent");
1724
1725 return skip;
1726 }
1727
PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize size,uint32_t data) const1728 bool ObjectLifetimes::PreCallValidateCmdFillBuffer(
1729 VkCommandBuffer commandBuffer,
1730 VkBuffer dstBuffer,
1731 VkDeviceSize dstOffset,
1732 VkDeviceSize size,
1733 uint32_t data) const {
1734 bool skip = false;
1735 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdFillBuffer-commandBuffer-parameter", "VUID-vkCmdFillBuffer-commonparent");
1736 skip |= ValidateObject(dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdFillBuffer-dstBuffer-parameter", "VUID-vkCmdFillBuffer-commonparent");
1737
1738 return skip;
1739 }
1740
PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearColorValue * pColor,uint32_t rangeCount,const VkImageSubresourceRange * pRanges) const1741 bool ObjectLifetimes::PreCallValidateCmdClearColorImage(
1742 VkCommandBuffer commandBuffer,
1743 VkImage image,
1744 VkImageLayout imageLayout,
1745 const VkClearColorValue* pColor,
1746 uint32_t rangeCount,
1747 const VkImageSubresourceRange* pRanges) const {
1748 bool skip = false;
1749 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdClearColorImage-commandBuffer-parameter", "VUID-vkCmdClearColorImage-commonparent");
1750 skip |= ValidateObject(image, kVulkanObjectTypeImage, false, "VUID-vkCmdClearColorImage-image-parameter", "VUID-vkCmdClearColorImage-commonparent");
1751
1752 return skip;
1753 }
1754
PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearDepthStencilValue * pDepthStencil,uint32_t rangeCount,const VkImageSubresourceRange * pRanges) const1755 bool ObjectLifetimes::PreCallValidateCmdClearDepthStencilImage(
1756 VkCommandBuffer commandBuffer,
1757 VkImage image,
1758 VkImageLayout imageLayout,
1759 const VkClearDepthStencilValue* pDepthStencil,
1760 uint32_t rangeCount,
1761 const VkImageSubresourceRange* pRanges) const {
1762 bool skip = false;
1763 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter", "VUID-vkCmdClearDepthStencilImage-commonparent");
1764 skip |= ValidateObject(image, kVulkanObjectTypeImage, false, "VUID-vkCmdClearDepthStencilImage-image-parameter", "VUID-vkCmdClearDepthStencilImage-commonparent");
1765
1766 return skip;
1767 }
1768
PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer,uint32_t attachmentCount,const VkClearAttachment * pAttachments,uint32_t rectCount,const VkClearRect * pRects) const1769 bool ObjectLifetimes::PreCallValidateCmdClearAttachments(
1770 VkCommandBuffer commandBuffer,
1771 uint32_t attachmentCount,
1772 const VkClearAttachment* pAttachments,
1773 uint32_t rectCount,
1774 const VkClearRect* pRects) const {
1775 bool skip = false;
1776 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdClearAttachments-commandBuffer-parameter", kVUIDUndefined);
1777
1778 return skip;
1779 }
1780
PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageResolve * pRegions) const1781 bool ObjectLifetimes::PreCallValidateCmdResolveImage(
1782 VkCommandBuffer commandBuffer,
1783 VkImage srcImage,
1784 VkImageLayout srcImageLayout,
1785 VkImage dstImage,
1786 VkImageLayout dstImageLayout,
1787 uint32_t regionCount,
1788 const VkImageResolve* pRegions) const {
1789 bool skip = false;
1790 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdResolveImage-commandBuffer-parameter", "VUID-vkCmdResolveImage-commonparent");
1791 skip |= ValidateObject(srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdResolveImage-srcImage-parameter", "VUID-vkCmdResolveImage-commonparent");
1792 skip |= ValidateObject(dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdResolveImage-dstImage-parameter", "VUID-vkCmdResolveImage-commonparent");
1793
1794 return skip;
1795 }
1796
PreCallValidateCmdSetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask) const1797 bool ObjectLifetimes::PreCallValidateCmdSetEvent(
1798 VkCommandBuffer commandBuffer,
1799 VkEvent event,
1800 VkPipelineStageFlags stageMask) const {
1801 bool skip = false;
1802 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetEvent-commandBuffer-parameter", "VUID-vkCmdSetEvent-commonparent");
1803 skip |= ValidateObject(event, kVulkanObjectTypeEvent, false, "VUID-vkCmdSetEvent-event-parameter", "VUID-vkCmdSetEvent-commonparent");
1804
1805 return skip;
1806 }
1807
PreCallValidateCmdResetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask) const1808 bool ObjectLifetimes::PreCallValidateCmdResetEvent(
1809 VkCommandBuffer commandBuffer,
1810 VkEvent event,
1811 VkPipelineStageFlags stageMask) const {
1812 bool skip = false;
1813 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdResetEvent-commandBuffer-parameter", "VUID-vkCmdResetEvent-commonparent");
1814 skip |= ValidateObject(event, kVulkanObjectTypeEvent, false, "VUID-vkCmdResetEvent-event-parameter", "VUID-vkCmdResetEvent-commonparent");
1815
1816 return skip;
1817 }
1818
PreCallValidateCmdWaitEvents(VkCommandBuffer commandBuffer,uint32_t eventCount,const VkEvent * pEvents,VkPipelineStageFlags srcStageMask,VkPipelineStageFlags dstStageMask,uint32_t memoryBarrierCount,const VkMemoryBarrier * pMemoryBarriers,uint32_t bufferMemoryBarrierCount,const VkBufferMemoryBarrier * pBufferMemoryBarriers,uint32_t imageMemoryBarrierCount,const VkImageMemoryBarrier * pImageMemoryBarriers) const1819 bool ObjectLifetimes::PreCallValidateCmdWaitEvents(
1820 VkCommandBuffer commandBuffer,
1821 uint32_t eventCount,
1822 const VkEvent* pEvents,
1823 VkPipelineStageFlags srcStageMask,
1824 VkPipelineStageFlags dstStageMask,
1825 uint32_t memoryBarrierCount,
1826 const VkMemoryBarrier* pMemoryBarriers,
1827 uint32_t bufferMemoryBarrierCount,
1828 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1829 uint32_t imageMemoryBarrierCount,
1830 const VkImageMemoryBarrier* pImageMemoryBarriers) const {
1831 bool skip = false;
1832 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWaitEvents-commandBuffer-parameter", "VUID-vkCmdWaitEvents-commonparent");
1833 if (pEvents) {
1834 for (uint32_t index0 = 0; index0 < eventCount; ++index0) {
1835 skip |= ValidateObject(pEvents[index0], kVulkanObjectTypeEvent, false, "VUID-vkCmdWaitEvents-pEvents-parameter", "VUID-vkCmdWaitEvents-commonparent");
1836 }
1837 }
1838 if (pBufferMemoryBarriers) {
1839 for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) {
1840 skip |= ValidateObject(pBufferMemoryBarriers[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryBarrier-buffer-parameter", kVUIDUndefined);
1841 }
1842 }
1843 if (pImageMemoryBarriers) {
1844 for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) {
1845 skip |= ValidateObject(pImageMemoryBarriers[index0].image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryBarrier-image-parameter", kVUIDUndefined);
1846 }
1847 }
1848
1849 return skip;
1850 }
1851
PreCallValidateCmdPipelineBarrier(VkCommandBuffer commandBuffer,VkPipelineStageFlags srcStageMask,VkPipelineStageFlags dstStageMask,VkDependencyFlags dependencyFlags,uint32_t memoryBarrierCount,const VkMemoryBarrier * pMemoryBarriers,uint32_t bufferMemoryBarrierCount,const VkBufferMemoryBarrier * pBufferMemoryBarriers,uint32_t imageMemoryBarrierCount,const VkImageMemoryBarrier * pImageMemoryBarriers) const1852 bool ObjectLifetimes::PreCallValidateCmdPipelineBarrier(
1853 VkCommandBuffer commandBuffer,
1854 VkPipelineStageFlags srcStageMask,
1855 VkPipelineStageFlags dstStageMask,
1856 VkDependencyFlags dependencyFlags,
1857 uint32_t memoryBarrierCount,
1858 const VkMemoryBarrier* pMemoryBarriers,
1859 uint32_t bufferMemoryBarrierCount,
1860 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1861 uint32_t imageMemoryBarrierCount,
1862 const VkImageMemoryBarrier* pImageMemoryBarriers) const {
1863 bool skip = false;
1864 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdPipelineBarrier-commandBuffer-parameter", kVUIDUndefined);
1865 if (pBufferMemoryBarriers) {
1866 for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) {
1867 skip |= ValidateObject(pBufferMemoryBarriers[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryBarrier-buffer-parameter", kVUIDUndefined);
1868 }
1869 }
1870 if (pImageMemoryBarriers) {
1871 for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) {
1872 skip |= ValidateObject(pImageMemoryBarriers[index0].image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryBarrier-image-parameter", kVUIDUndefined);
1873 }
1874 }
1875
1876 return skip;
1877 }
1878
PreCallValidateCmdBeginQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,VkQueryControlFlags flags) const1879 bool ObjectLifetimes::PreCallValidateCmdBeginQuery(
1880 VkCommandBuffer commandBuffer,
1881 VkQueryPool queryPool,
1882 uint32_t query,
1883 VkQueryControlFlags flags) const {
1884 bool skip = false;
1885 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginQuery-commandBuffer-parameter", "VUID-vkCmdBeginQuery-commonparent");
1886 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdBeginQuery-queryPool-parameter", "VUID-vkCmdBeginQuery-commonparent");
1887
1888 return skip;
1889 }
1890
PreCallValidateCmdEndQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query) const1891 bool ObjectLifetimes::PreCallValidateCmdEndQuery(
1892 VkCommandBuffer commandBuffer,
1893 VkQueryPool queryPool,
1894 uint32_t query) const {
1895 bool skip = false;
1896 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndQuery-commandBuffer-parameter", "VUID-vkCmdEndQuery-commonparent");
1897 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdEndQuery-queryPool-parameter", "VUID-vkCmdEndQuery-commonparent");
1898
1899 return skip;
1900 }
1901
PreCallValidateCmdResetQueryPool(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const1902 bool ObjectLifetimes::PreCallValidateCmdResetQueryPool(
1903 VkCommandBuffer commandBuffer,
1904 VkQueryPool queryPool,
1905 uint32_t firstQuery,
1906 uint32_t queryCount) const {
1907 bool skip = false;
1908 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdResetQueryPool-commandBuffer-parameter", "VUID-vkCmdResetQueryPool-commonparent");
1909 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdResetQueryPool-queryPool-parameter", "VUID-vkCmdResetQueryPool-commonparent");
1910
1911 return skip;
1912 }
1913
PreCallValidateCmdWriteTimestamp(VkCommandBuffer commandBuffer,VkPipelineStageFlagBits pipelineStage,VkQueryPool queryPool,uint32_t query) const1914 bool ObjectLifetimes::PreCallValidateCmdWriteTimestamp(
1915 VkCommandBuffer commandBuffer,
1916 VkPipelineStageFlagBits pipelineStage,
1917 VkQueryPool queryPool,
1918 uint32_t query) const {
1919 bool skip = false;
1920 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWriteTimestamp-commandBuffer-parameter", "VUID-vkCmdWriteTimestamp-commonparent");
1921 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdWriteTimestamp-queryPool-parameter", "VUID-vkCmdWriteTimestamp-commonparent");
1922
1923 return skip;
1924 }
1925
PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize stride,VkQueryResultFlags flags) const1926 bool ObjectLifetimes::PreCallValidateCmdCopyQueryPoolResults(
1927 VkCommandBuffer commandBuffer,
1928 VkQueryPool queryPool,
1929 uint32_t firstQuery,
1930 uint32_t queryCount,
1931 VkBuffer dstBuffer,
1932 VkDeviceSize dstOffset,
1933 VkDeviceSize stride,
1934 VkQueryResultFlags flags) const {
1935 bool skip = false;
1936 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter", "VUID-vkCmdCopyQueryPoolResults-commonparent");
1937 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdCopyQueryPoolResults-queryPool-parameter", "VUID-vkCmdCopyQueryPoolResults-commonparent");
1938 skip |= ValidateObject(dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter", "VUID-vkCmdCopyQueryPoolResults-commonparent");
1939
1940 return skip;
1941 }
1942
PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer,VkPipelineLayout layout,VkShaderStageFlags stageFlags,uint32_t offset,uint32_t size,const void * pValues) const1943 bool ObjectLifetimes::PreCallValidateCmdPushConstants(
1944 VkCommandBuffer commandBuffer,
1945 VkPipelineLayout layout,
1946 VkShaderStageFlags stageFlags,
1947 uint32_t offset,
1948 uint32_t size,
1949 const void* pValues) const {
1950 bool skip = false;
1951 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdPushConstants-commandBuffer-parameter", "VUID-vkCmdPushConstants-commonparent");
1952 skip |= ValidateObject(layout, kVulkanObjectTypePipelineLayout, false, "VUID-vkCmdPushConstants-layout-parameter", "VUID-vkCmdPushConstants-commonparent");
1953
1954 return skip;
1955 }
1956
PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,VkSubpassContents contents) const1957 bool ObjectLifetimes::PreCallValidateCmdBeginRenderPass(
1958 VkCommandBuffer commandBuffer,
1959 const VkRenderPassBeginInfo* pRenderPassBegin,
1960 VkSubpassContents contents) const {
1961 bool skip = false;
1962 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginRenderPass-commandBuffer-parameter", kVUIDUndefined);
1963 if (pRenderPassBegin) {
1964 skip |= ValidateObject(pRenderPassBegin->renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkRenderPassBeginInfo-renderPass-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
1965 skip |= ValidateObject(pRenderPassBegin->framebuffer, kVulkanObjectTypeFramebuffer, false, "VUID-VkRenderPassBeginInfo-framebuffer-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
1966 }
1967
1968 return skip;
1969 }
1970
PreCallValidateCmdNextSubpass(VkCommandBuffer commandBuffer,VkSubpassContents contents) const1971 bool ObjectLifetimes::PreCallValidateCmdNextSubpass(
1972 VkCommandBuffer commandBuffer,
1973 VkSubpassContents contents) const {
1974 bool skip = false;
1975 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdNextSubpass-commandBuffer-parameter", kVUIDUndefined);
1976
1977 return skip;
1978 }
1979
PreCallValidateCmdEndRenderPass(VkCommandBuffer commandBuffer) const1980 bool ObjectLifetimes::PreCallValidateCmdEndRenderPass(
1981 VkCommandBuffer commandBuffer) const {
1982 bool skip = false;
1983 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndRenderPass-commandBuffer-parameter", kVUIDUndefined);
1984
1985 return skip;
1986 }
1987
PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer,uint32_t commandBufferCount,const VkCommandBuffer * pCommandBuffers) const1988 bool ObjectLifetimes::PreCallValidateCmdExecuteCommands(
1989 VkCommandBuffer commandBuffer,
1990 uint32_t commandBufferCount,
1991 const VkCommandBuffer* pCommandBuffers) const {
1992 bool skip = false;
1993 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdExecuteCommands-commandBuffer-parameter", "VUID-vkCmdExecuteCommands-commonparent");
1994 if (pCommandBuffers) {
1995 for (uint32_t index0 = 0; index0 < commandBufferCount; ++index0) {
1996 skip |= ValidateObject(pCommandBuffers[index0], kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdExecuteCommands-pCommandBuffers-parameter", "VUID-vkCmdExecuteCommands-commonparent");
1997 }
1998 }
1999
2000 return skip;
2001 }
2002
PreCallValidateBindBufferMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindBufferMemoryInfo * pBindInfos) const2003 bool ObjectLifetimes::PreCallValidateBindBufferMemory2(
2004 VkDevice device,
2005 uint32_t bindInfoCount,
2006 const VkBindBufferMemoryInfo* pBindInfos) const {
2007 bool skip = false;
2008 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindBufferMemory2-device-parameter", kVUIDUndefined);
2009 if (pBindInfos) {
2010 for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
2011 skip |= ValidateObject(pBindInfos[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBindBufferMemoryInfo-buffer-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
2012 skip |= ValidateObject(pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkBindBufferMemoryInfo-memory-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
2013 }
2014 }
2015
2016 return skip;
2017 }
2018
PreCallValidateBindImageMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos) const2019 bool ObjectLifetimes::PreCallValidateBindImageMemory2(
2020 VkDevice device,
2021 uint32_t bindInfoCount,
2022 const VkBindImageMemoryInfo* pBindInfos) const {
2023 bool skip = false;
2024 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindImageMemory2-device-parameter", kVUIDUndefined);
2025 if (pBindInfos) {
2026 for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
2027 skip |= ValidateObject(pBindInfos[index0].image, kVulkanObjectTypeImage, false, "VUID-VkBindImageMemoryInfo-image-parameter", "VUID-VkBindImageMemoryInfo-commonparent");
2028 skip |= ValidateObject(pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, true, kVUIDUndefined, "VUID-VkBindImageMemoryInfo-commonparent");
2029 }
2030 }
2031
2032 return skip;
2033 }
2034
PreCallValidateGetDeviceGroupPeerMemoryFeatures(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) const2035 bool ObjectLifetimes::PreCallValidateGetDeviceGroupPeerMemoryFeatures(
2036 VkDevice device,
2037 uint32_t heapIndex,
2038 uint32_t localDeviceIndex,
2039 uint32_t remoteDeviceIndex,
2040 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const {
2041 bool skip = false;
2042 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", kVUIDUndefined);
2043
2044 return skip;
2045 }
2046
PreCallValidateCmdSetDeviceMask(VkCommandBuffer commandBuffer,uint32_t deviceMask) const2047 bool ObjectLifetimes::PreCallValidateCmdSetDeviceMask(
2048 VkCommandBuffer commandBuffer,
2049 uint32_t deviceMask) const {
2050 bool skip = false;
2051 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDeviceMask-commandBuffer-parameter", kVUIDUndefined);
2052
2053 return skip;
2054 }
2055
PreCallValidateCmdDispatchBase(VkCommandBuffer commandBuffer,uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const2056 bool ObjectLifetimes::PreCallValidateCmdDispatchBase(
2057 VkCommandBuffer commandBuffer,
2058 uint32_t baseGroupX,
2059 uint32_t baseGroupY,
2060 uint32_t baseGroupZ,
2061 uint32_t groupCountX,
2062 uint32_t groupCountY,
2063 uint32_t groupCountZ) const {
2064 bool skip = false;
2065 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatchBase-commandBuffer-parameter", kVUIDUndefined);
2066
2067 return skip;
2068 }
2069
PreCallValidateEnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) const2070 bool ObjectLifetimes::PreCallValidateEnumeratePhysicalDeviceGroups(
2071 VkInstance instance,
2072 uint32_t* pPhysicalDeviceGroupCount,
2073 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const {
2074 bool skip = false;
2075 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", kVUIDUndefined);
2076
2077 return skip;
2078 }
2079
PreCallValidateGetImageMemoryRequirements2(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const2080 bool ObjectLifetimes::PreCallValidateGetImageMemoryRequirements2(
2081 VkDevice device,
2082 const VkImageMemoryRequirementsInfo2* pInfo,
2083 VkMemoryRequirements2* pMemoryRequirements) const {
2084 bool skip = false;
2085 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageMemoryRequirements2-device-parameter", kVUIDUndefined);
2086 if (pInfo) {
2087 skip |= ValidateObject(pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
2088 }
2089
2090 return skip;
2091 }
2092
PreCallValidateGetBufferMemoryRequirements2(VkDevice device,const VkBufferMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const2093 bool ObjectLifetimes::PreCallValidateGetBufferMemoryRequirements2(
2094 VkDevice device,
2095 const VkBufferMemoryRequirementsInfo2* pInfo,
2096 VkMemoryRequirements2* pMemoryRequirements) const {
2097 bool skip = false;
2098 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferMemoryRequirements2-device-parameter", kVUIDUndefined);
2099 if (pInfo) {
2100 skip |= ValidateObject(pInfo->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", kVUIDUndefined);
2101 }
2102
2103 return skip;
2104 }
2105
PreCallValidateGetImageSparseMemoryRequirements2(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) const2106 bool ObjectLifetimes::PreCallValidateGetImageSparseMemoryRequirements2(
2107 VkDevice device,
2108 const VkImageSparseMemoryRequirementsInfo2* pInfo,
2109 uint32_t* pSparseMemoryRequirementCount,
2110 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const {
2111 bool skip = false;
2112 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSparseMemoryRequirements2-device-parameter", kVUIDUndefined);
2113 if (pInfo) {
2114 skip |= ValidateObject(pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
2115 }
2116
2117 return skip;
2118 }
2119
PreCallValidateGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures) const2120 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFeatures2(
2121 VkPhysicalDevice physicalDevice,
2122 VkPhysicalDeviceFeatures2* pFeatures) const {
2123 bool skip = false;
2124 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", kVUIDUndefined);
2125
2126 return skip;
2127 }
2128
PreCallValidateGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties) const2129 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceProperties2(
2130 VkPhysicalDevice physicalDevice,
2131 VkPhysicalDeviceProperties2* pProperties) const {
2132 bool skip = false;
2133 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", kVUIDUndefined);
2134
2135 return skip;
2136 }
2137
PreCallValidateGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties) const2138 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFormatProperties2(
2139 VkPhysicalDevice physicalDevice,
2140 VkFormat format,
2141 VkFormatProperties2* pFormatProperties) const {
2142 bool skip = false;
2143 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
2144
2145 return skip;
2146 }
2147
PreCallValidateGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties) const2148 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceImageFormatProperties2(
2149 VkPhysicalDevice physicalDevice,
2150 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
2151 VkImageFormatProperties2* pImageFormatProperties) const {
2152 bool skip = false;
2153 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
2154
2155 return skip;
2156 }
2157
PreCallValidateGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) const2158 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMemoryProperties2(
2159 VkPhysicalDevice physicalDevice,
2160 VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const {
2161 bool skip = false;
2162 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", kVUIDUndefined);
2163
2164 return skip;
2165 }
2166
PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties) const2167 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(
2168 VkPhysicalDevice physicalDevice,
2169 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
2170 uint32_t* pPropertyCount,
2171 VkSparseImageFormatProperties2* pProperties) const {
2172 bool skip = false;
2173 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
2174
2175 return skip;
2176 }
2177
PreCallValidateTrimCommandPool(VkDevice device,VkCommandPool commandPool,VkCommandPoolTrimFlags flags) const2178 bool ObjectLifetimes::PreCallValidateTrimCommandPool(
2179 VkDevice device,
2180 VkCommandPool commandPool,
2181 VkCommandPoolTrimFlags flags) const {
2182 bool skip = false;
2183 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkTrimCommandPool-device-parameter", kVUIDUndefined);
2184 skip |= ValidateObject(commandPool, kVulkanObjectTypeCommandPool, false, "VUID-vkTrimCommandPool-commandPool-parameter", "VUID-vkTrimCommandPool-commandPool-parent");
2185
2186 return skip;
2187 }
2188
PreCallValidateCreateSamplerYcbcrConversion(VkDevice device,const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSamplerYcbcrConversion * pYcbcrConversion) const2189 bool ObjectLifetimes::PreCallValidateCreateSamplerYcbcrConversion(
2190 VkDevice device,
2191 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
2192 const VkAllocationCallbacks* pAllocator,
2193 VkSamplerYcbcrConversion* pYcbcrConversion) const {
2194 bool skip = false;
2195 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSamplerYcbcrConversion-device-parameter", kVUIDUndefined);
2196
2197 return skip;
2198 }
2199
PostCallRecordCreateSamplerYcbcrConversion(VkDevice device,const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSamplerYcbcrConversion * pYcbcrConversion,VkResult result)2200 void ObjectLifetimes::PostCallRecordCreateSamplerYcbcrConversion(
2201 VkDevice device,
2202 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
2203 const VkAllocationCallbacks* pAllocator,
2204 VkSamplerYcbcrConversion* pYcbcrConversion,
2205 VkResult result) {
2206 if (result != VK_SUCCESS) return;
2207 CreateObject(*pYcbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator);
2208
2209 }
2210
PreCallValidateDestroySamplerYcbcrConversion(VkDevice device,VkSamplerYcbcrConversion ycbcrConversion,const VkAllocationCallbacks * pAllocator) const2211 bool ObjectLifetimes::PreCallValidateDestroySamplerYcbcrConversion(
2212 VkDevice device,
2213 VkSamplerYcbcrConversion ycbcrConversion,
2214 const VkAllocationCallbacks* pAllocator) const {
2215 bool skip = false;
2216 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySamplerYcbcrConversion-device-parameter", kVUIDUndefined);
2217 skip |= ValidateObject(ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, true, "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent");
2218 skip |= ValidateDestroyObject(ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator, kVUIDUndefined, kVUIDUndefined);
2219
2220 return skip;
2221 }
2222
PreCallRecordDestroySamplerYcbcrConversion(VkDevice device,VkSamplerYcbcrConversion ycbcrConversion,const VkAllocationCallbacks * pAllocator)2223 void ObjectLifetimes::PreCallRecordDestroySamplerYcbcrConversion(
2224 VkDevice device,
2225 VkSamplerYcbcrConversion ycbcrConversion,
2226 const VkAllocationCallbacks* pAllocator) {
2227 RecordDestroyObject(ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion);
2228
2229 }
2230
PreCallValidateDestroyDescriptorUpdateTemplate(VkDevice device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const VkAllocationCallbacks * pAllocator) const2231 bool ObjectLifetimes::PreCallValidateDestroyDescriptorUpdateTemplate(
2232 VkDevice device,
2233 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2234 const VkAllocationCallbacks* pAllocator) const {
2235 bool skip = false;
2236 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", kVUIDUndefined);
2237 skip |= ValidateObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, true, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent");
2238 skip |= ValidateDestroyObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357");
2239
2240 return skip;
2241 }
2242
PreCallRecordDestroyDescriptorUpdateTemplate(VkDevice device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const VkAllocationCallbacks * pAllocator)2243 void ObjectLifetimes::PreCallRecordDestroyDescriptorUpdateTemplate(
2244 VkDevice device,
2245 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2246 const VkAllocationCallbacks* pAllocator) {
2247 RecordDestroyObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate);
2248
2249 }
2250
PreCallValidateUpdateDescriptorSetWithTemplate(VkDevice device,VkDescriptorSet descriptorSet,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData) const2251 bool ObjectLifetimes::PreCallValidateUpdateDescriptorSetWithTemplate(
2252 VkDevice device,
2253 VkDescriptorSet descriptorSet,
2254 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2255 const void* pData) const {
2256 bool skip = false;
2257 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSetWithTemplate-device-parameter", kVUIDUndefined);
2258 skip |= ValidateObject(descriptorSet, kVulkanObjectTypeDescriptorSet, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter", kVUIDUndefined);
2259 skip |= ValidateObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter", "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent");
2260
2261 return skip;
2262 }
2263
PreCallValidateGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties) const2264 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalBufferProperties(
2265 VkPhysicalDevice physicalDevice,
2266 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
2267 VkExternalBufferProperties* pExternalBufferProperties) const {
2268 bool skip = false;
2269 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", kVUIDUndefined);
2270
2271 return skip;
2272 }
2273
PreCallValidateGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties) const2274 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalFenceProperties(
2275 VkPhysicalDevice physicalDevice,
2276 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
2277 VkExternalFenceProperties* pExternalFenceProperties) const {
2278 bool skip = false;
2279 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", kVUIDUndefined);
2280
2281 return skip;
2282 }
2283
PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties) const2284 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(
2285 VkPhysicalDevice physicalDevice,
2286 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
2287 VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const {
2288 bool skip = false;
2289 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", kVUIDUndefined);
2290
2291 return skip;
2292 }
2293
PreCallValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const2294 bool ObjectLifetimes::PreCallValidateCmdDrawIndirectCount(
2295 VkCommandBuffer commandBuffer,
2296 VkBuffer buffer,
2297 VkDeviceSize offset,
2298 VkBuffer countBuffer,
2299 VkDeviceSize countBufferOffset,
2300 uint32_t maxDrawCount,
2301 uint32_t stride) const {
2302 bool skip = false;
2303 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirectCount-commandBuffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
2304 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCount-buffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
2305 skip |= ValidateObject(countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCount-countBuffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
2306
2307 return skip;
2308 }
2309
PreCallValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const2310 bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirectCount(
2311 VkCommandBuffer commandBuffer,
2312 VkBuffer buffer,
2313 VkDeviceSize offset,
2314 VkBuffer countBuffer,
2315 VkDeviceSize countBufferOffset,
2316 uint32_t maxDrawCount,
2317 uint32_t stride) const {
2318 bool skip = false;
2319 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
2320 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-buffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
2321 skip |= ValidateObject(countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
2322
2323 return skip;
2324 }
2325
PreCallValidateCreateRenderPass2(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const2326 bool ObjectLifetimes::PreCallValidateCreateRenderPass2(
2327 VkDevice device,
2328 const VkRenderPassCreateInfo2* pCreateInfo,
2329 const VkAllocationCallbacks* pAllocator,
2330 VkRenderPass* pRenderPass) const {
2331 bool skip = false;
2332 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRenderPass2-device-parameter", kVUIDUndefined);
2333
2334 return skip;
2335 }
2336
PostCallRecordCreateRenderPass2(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass,VkResult result)2337 void ObjectLifetimes::PostCallRecordCreateRenderPass2(
2338 VkDevice device,
2339 const VkRenderPassCreateInfo2* pCreateInfo,
2340 const VkAllocationCallbacks* pAllocator,
2341 VkRenderPass* pRenderPass,
2342 VkResult result) {
2343 if (result != VK_SUCCESS) return;
2344 CreateObject(*pRenderPass, kVulkanObjectTypeRenderPass, pAllocator);
2345
2346 }
2347
PreCallValidateCmdBeginRenderPass2(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,const VkSubpassBeginInfo * pSubpassBeginInfo) const2348 bool ObjectLifetimes::PreCallValidateCmdBeginRenderPass2(
2349 VkCommandBuffer commandBuffer,
2350 const VkRenderPassBeginInfo* pRenderPassBegin,
2351 const VkSubpassBeginInfo* pSubpassBeginInfo) const {
2352 bool skip = false;
2353 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginRenderPass2-commandBuffer-parameter", kVUIDUndefined);
2354 if (pRenderPassBegin) {
2355 skip |= ValidateObject(pRenderPassBegin->renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkRenderPassBeginInfo-renderPass-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
2356 skip |= ValidateObject(pRenderPassBegin->framebuffer, kVulkanObjectTypeFramebuffer, false, "VUID-VkRenderPassBeginInfo-framebuffer-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
2357 }
2358
2359 return skip;
2360 }
2361
PreCallValidateCmdNextSubpass2(VkCommandBuffer commandBuffer,const VkSubpassBeginInfo * pSubpassBeginInfo,const VkSubpassEndInfo * pSubpassEndInfo) const2362 bool ObjectLifetimes::PreCallValidateCmdNextSubpass2(
2363 VkCommandBuffer commandBuffer,
2364 const VkSubpassBeginInfo* pSubpassBeginInfo,
2365 const VkSubpassEndInfo* pSubpassEndInfo) const {
2366 bool skip = false;
2367 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdNextSubpass2-commandBuffer-parameter", kVUIDUndefined);
2368
2369 return skip;
2370 }
2371
PreCallValidateCmdEndRenderPass2(VkCommandBuffer commandBuffer,const VkSubpassEndInfo * pSubpassEndInfo) const2372 bool ObjectLifetimes::PreCallValidateCmdEndRenderPass2(
2373 VkCommandBuffer commandBuffer,
2374 const VkSubpassEndInfo* pSubpassEndInfo) const {
2375 bool skip = false;
2376 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndRenderPass2-commandBuffer-parameter", kVUIDUndefined);
2377
2378 return skip;
2379 }
2380
PreCallValidateResetQueryPool(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const2381 bool ObjectLifetimes::PreCallValidateResetQueryPool(
2382 VkDevice device,
2383 VkQueryPool queryPool,
2384 uint32_t firstQuery,
2385 uint32_t queryCount) const {
2386 bool skip = false;
2387 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkResetQueryPool-device-parameter", kVUIDUndefined);
2388 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkResetQueryPool-queryPool-parameter", "VUID-vkResetQueryPool-queryPool-parent");
2389
2390 return skip;
2391 }
2392
PreCallValidateGetSemaphoreCounterValue(VkDevice device,VkSemaphore semaphore,uint64_t * pValue) const2393 bool ObjectLifetimes::PreCallValidateGetSemaphoreCounterValue(
2394 VkDevice device,
2395 VkSemaphore semaphore,
2396 uint64_t* pValue) const {
2397 bool skip = false;
2398 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetSemaphoreCounterValue-device-parameter", kVUIDUndefined);
2399 skip |= ValidateObject(semaphore, kVulkanObjectTypeSemaphore, false, "VUID-vkGetSemaphoreCounterValue-semaphore-parameter", "VUID-vkGetSemaphoreCounterValue-semaphore-parent");
2400
2401 return skip;
2402 }
2403
PreCallValidateWaitSemaphores(VkDevice device,const VkSemaphoreWaitInfo * pWaitInfo,uint64_t timeout) const2404 bool ObjectLifetimes::PreCallValidateWaitSemaphores(
2405 VkDevice device,
2406 const VkSemaphoreWaitInfo* pWaitInfo,
2407 uint64_t timeout) const {
2408 bool skip = false;
2409 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkWaitSemaphores-device-parameter", kVUIDUndefined);
2410 if (pWaitInfo) {
2411 if (pWaitInfo->pSemaphores) {
2412 for (uint32_t index1 = 0; index1 < pWaitInfo->semaphoreCount; ++index1) {
2413 skip |= ValidateObject(pWaitInfo->pSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreWaitInfo-pSemaphores-parameter", kVUIDUndefined);
2414 }
2415 }
2416 }
2417
2418 return skip;
2419 }
2420
PreCallValidateSignalSemaphore(VkDevice device,const VkSemaphoreSignalInfo * pSignalInfo) const2421 bool ObjectLifetimes::PreCallValidateSignalSemaphore(
2422 VkDevice device,
2423 const VkSemaphoreSignalInfo* pSignalInfo) const {
2424 bool skip = false;
2425 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkSignalSemaphore-device-parameter", kVUIDUndefined);
2426 if (pSignalInfo) {
2427 skip |= ValidateObject(pSignalInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreSignalInfo-semaphore-parameter", kVUIDUndefined);
2428 }
2429
2430 return skip;
2431 }
2432
PreCallValidateGetBufferDeviceAddress(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const2433 bool ObjectLifetimes::PreCallValidateGetBufferDeviceAddress(
2434 VkDevice device,
2435 const VkBufferDeviceAddressInfo* pInfo) const {
2436 bool skip = false;
2437 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferDeviceAddress-device-parameter", kVUIDUndefined);
2438
2439 return skip;
2440 }
2441
PreCallValidateGetBufferOpaqueCaptureAddress(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const2442 bool ObjectLifetimes::PreCallValidateGetBufferOpaqueCaptureAddress(
2443 VkDevice device,
2444 const VkBufferDeviceAddressInfo* pInfo) const {
2445 bool skip = false;
2446 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferOpaqueCaptureAddress-device-parameter", kVUIDUndefined);
2447
2448 return skip;
2449 }
2450
PreCallValidateGetDeviceMemoryOpaqueCaptureAddress(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo) const2451 bool ObjectLifetimes::PreCallValidateGetDeviceMemoryOpaqueCaptureAddress(
2452 VkDevice device,
2453 const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const {
2454 bool skip = false;
2455 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceMemoryOpaqueCaptureAddress-device-parameter", kVUIDUndefined);
2456
2457 return skip;
2458 }
2459
PreCallValidateDestroySurfaceKHR(VkInstance instance,VkSurfaceKHR surface,const VkAllocationCallbacks * pAllocator) const2460 bool ObjectLifetimes::PreCallValidateDestroySurfaceKHR(
2461 VkInstance instance,
2462 VkSurfaceKHR surface,
2463 const VkAllocationCallbacks* pAllocator) const {
2464 bool skip = false;
2465 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkDestroySurfaceKHR-instance-parameter", kVUIDUndefined);
2466 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, true, "VUID-vkDestroySurfaceKHR-surface-parameter", "VUID-vkDestroySurfaceKHR-surface-parent");
2467 skip |= ValidateDestroyObject(surface, kVulkanObjectTypeSurfaceKHR, pAllocator, "VUID-vkDestroySurfaceKHR-surface-01267", "VUID-vkDestroySurfaceKHR-surface-01268");
2468
2469 return skip;
2470 }
2471
PreCallRecordDestroySurfaceKHR(VkInstance instance,VkSurfaceKHR surface,const VkAllocationCallbacks * pAllocator)2472 void ObjectLifetimes::PreCallRecordDestroySurfaceKHR(
2473 VkInstance instance,
2474 VkSurfaceKHR surface,
2475 const VkAllocationCallbacks* pAllocator) {
2476 RecordDestroyObject(surface, kVulkanObjectTypeSurfaceKHR);
2477
2478 }
2479
PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,VkSurfaceKHR surface,VkBool32 * pSupported) const2480 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(
2481 VkPhysicalDevice physicalDevice,
2482 uint32_t queueFamilyIndex,
2483 VkSurfaceKHR surface,
2484 VkBool32* pSupported) const {
2485 bool skip = false;
2486 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent");
2487 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent");
2488
2489 return skip;
2490 }
2491
PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilitiesKHR * pSurfaceCapabilities) const2492 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(
2493 VkPhysicalDevice physicalDevice,
2494 VkSurfaceKHR surface,
2495 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) const {
2496 bool skip = false;
2497 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent");
2498 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent");
2499
2500 return skip;
2501 }
2502
PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pSurfaceFormatCount,VkSurfaceFormatKHR * pSurfaceFormats) const2503 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(
2504 VkPhysicalDevice physicalDevice,
2505 VkSurfaceKHR surface,
2506 uint32_t* pSurfaceFormatCount,
2507 VkSurfaceFormatKHR* pSurfaceFormats) const {
2508 bool skip = false;
2509 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent");
2510 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent");
2511
2512 return skip;
2513 }
2514
PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pPresentModeCount,VkPresentModeKHR * pPresentModes) const2515 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(
2516 VkPhysicalDevice physicalDevice,
2517 VkSurfaceKHR surface,
2518 uint32_t* pPresentModeCount,
2519 VkPresentModeKHR* pPresentModes) const {
2520 bool skip = false;
2521 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent");
2522 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent");
2523
2524 return skip;
2525 }
2526
PreCallValidateCreateSwapchainKHR(VkDevice device,const VkSwapchainCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchain) const2527 bool ObjectLifetimes::PreCallValidateCreateSwapchainKHR(
2528 VkDevice device,
2529 const VkSwapchainCreateInfoKHR* pCreateInfo,
2530 const VkAllocationCallbacks* pAllocator,
2531 VkSwapchainKHR* pSwapchain) const {
2532 bool skip = false;
2533 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSwapchainKHR-device-parameter", kVUIDUndefined);
2534 if (pCreateInfo) {
2535 skip |= ValidateObject(pCreateInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkSwapchainCreateInfoKHR-surface-parameter", "VUID-VkSwapchainCreateInfoKHR-commonparent");
2536 skip |= ValidateObject(pCreateInfo->oldSwapchain, kVulkanObjectTypeSwapchainKHR, true, "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter", "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent");
2537 }
2538
2539 return skip;
2540 }
2541
PostCallRecordCreateSwapchainKHR(VkDevice device,const VkSwapchainCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchain,VkResult result)2542 void ObjectLifetimes::PostCallRecordCreateSwapchainKHR(
2543 VkDevice device,
2544 const VkSwapchainCreateInfoKHR* pCreateInfo,
2545 const VkAllocationCallbacks* pAllocator,
2546 VkSwapchainKHR* pSwapchain,
2547 VkResult result) {
2548 if (result != VK_SUCCESS) return;
2549 CreateObject(*pSwapchain, kVulkanObjectTypeSwapchainKHR, pAllocator);
2550
2551 }
2552
PreCallValidateAcquireNextImageKHR(VkDevice device,VkSwapchainKHR swapchain,uint64_t timeout,VkSemaphore semaphore,VkFence fence,uint32_t * pImageIndex) const2553 bool ObjectLifetimes::PreCallValidateAcquireNextImageKHR(
2554 VkDevice device,
2555 VkSwapchainKHR swapchain,
2556 uint64_t timeout,
2557 VkSemaphore semaphore,
2558 VkFence fence,
2559 uint32_t* pImageIndex) const {
2560 bool skip = false;
2561 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkAcquireNextImageKHR-device-parameter", "VUID-vkAcquireNextImageKHR-commonparent");
2562 skip |= ValidateObject(swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkAcquireNextImageKHR-swapchain-parameter", "VUID-vkAcquireNextImageKHR-commonparent");
2563 skip |= ValidateObject(semaphore, kVulkanObjectTypeSemaphore, true, "VUID-vkAcquireNextImageKHR-semaphore-parameter", "VUID-vkAcquireNextImageKHR-semaphore-parent");
2564 skip |= ValidateObject(fence, kVulkanObjectTypeFence, true, "VUID-vkAcquireNextImageKHR-fence-parameter", "VUID-vkAcquireNextImageKHR-fence-parent");
2565
2566 return skip;
2567 }
2568
PreCallValidateQueuePresentKHR(VkQueue queue,const VkPresentInfoKHR * pPresentInfo) const2569 bool ObjectLifetimes::PreCallValidateQueuePresentKHR(
2570 VkQueue queue,
2571 const VkPresentInfoKHR* pPresentInfo) const {
2572 bool skip = false;
2573 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueuePresentKHR-queue-parameter", kVUIDUndefined);
2574 if (pPresentInfo) {
2575 if (pPresentInfo->pWaitSemaphores) {
2576 for (uint32_t index1 = 0; index1 < pPresentInfo->waitSemaphoreCount; ++index1) {
2577 skip |= ValidateObject(pPresentInfo->pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkPresentInfoKHR-pWaitSemaphores-parameter", "VUID-VkPresentInfoKHR-commonparent");
2578 }
2579 }
2580 if (pPresentInfo->pSwapchains) {
2581 for (uint32_t index1 = 0; index1 < pPresentInfo->swapchainCount; ++index1) {
2582 skip |= ValidateObject(pPresentInfo->pSwapchains[index1], kVulkanObjectTypeSwapchainKHR, false, "VUID-VkPresentInfoKHR-pSwapchains-parameter", "VUID-VkPresentInfoKHR-commonparent");
2583 }
2584 }
2585 }
2586
2587 return skip;
2588 }
2589
PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(VkDevice device,VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities) const2590 bool ObjectLifetimes::PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(
2591 VkDevice device,
2592 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const {
2593 bool skip = false;
2594 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter", kVUIDUndefined);
2595
2596 return skip;
2597 }
2598
PreCallValidateGetDeviceGroupSurfacePresentModesKHR(VkDevice device,VkSurfaceKHR surface,VkDeviceGroupPresentModeFlagsKHR * pModes) const2599 bool ObjectLifetimes::PreCallValidateGetDeviceGroupSurfacePresentModesKHR(
2600 VkDevice device,
2601 VkSurfaceKHR surface,
2602 VkDeviceGroupPresentModeFlagsKHR* pModes) const {
2603 bool skip = false;
2604 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter", "VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent");
2605 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter", "VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent");
2606
2607 return skip;
2608 }
2609
PreCallValidateGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pRectCount,VkRect2D * pRects) const2610 bool ObjectLifetimes::PreCallValidateGetPhysicalDevicePresentRectanglesKHR(
2611 VkPhysicalDevice physicalDevice,
2612 VkSurfaceKHR surface,
2613 uint32_t* pRectCount,
2614 VkRect2D* pRects) const {
2615 bool skip = false;
2616 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent");
2617 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter", "VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent");
2618
2619 return skip;
2620 }
2621
PreCallValidateAcquireNextImage2KHR(VkDevice device,const VkAcquireNextImageInfoKHR * pAcquireInfo,uint32_t * pImageIndex) const2622 bool ObjectLifetimes::PreCallValidateAcquireNextImage2KHR(
2623 VkDevice device,
2624 const VkAcquireNextImageInfoKHR* pAcquireInfo,
2625 uint32_t* pImageIndex) const {
2626 bool skip = false;
2627 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkAcquireNextImage2KHR-device-parameter", kVUIDUndefined);
2628 if (pAcquireInfo) {
2629 skip |= ValidateObject(pAcquireInfo->swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-VkAcquireNextImageInfoKHR-swapchain-parameter", "VUID-VkAcquireNextImageInfoKHR-commonparent");
2630 skip |= ValidateObject(pAcquireInfo->semaphore, kVulkanObjectTypeSemaphore, true, "VUID-VkAcquireNextImageInfoKHR-semaphore-parameter", "VUID-VkAcquireNextImageInfoKHR-commonparent");
2631 skip |= ValidateObject(pAcquireInfo->fence, kVulkanObjectTypeFence, true, "VUID-VkAcquireNextImageInfoKHR-fence-parameter", "VUID-VkAcquireNextImageInfoKHR-commonparent");
2632 }
2633
2634 return skip;
2635 }
2636
PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPlanePropertiesKHR * pProperties) const2637 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(
2638 VkPhysicalDevice physicalDevice,
2639 uint32_t* pPropertyCount,
2640 VkDisplayPlanePropertiesKHR* pProperties) const {
2641 bool skip = false;
2642 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
2643
2644 return skip;
2645 }
2646
PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,uint32_t planeIndex,uint32_t * pDisplayCount,VkDisplayKHR * pDisplays) const2647 bool ObjectLifetimes::PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(
2648 VkPhysicalDevice physicalDevice,
2649 uint32_t planeIndex,
2650 uint32_t* pDisplayCount,
2651 VkDisplayKHR* pDisplays) const {
2652 bool skip = false;
2653 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", kVUIDUndefined);
2654
2655 return skip;
2656 }
2657
PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,uint32_t planeIndex,uint32_t * pDisplayCount,VkDisplayKHR * pDisplays,VkResult result)2658 void ObjectLifetimes::PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(
2659 VkPhysicalDevice physicalDevice,
2660 uint32_t planeIndex,
2661 uint32_t* pDisplayCount,
2662 VkDisplayKHR* pDisplays,
2663 VkResult result) {
2664 if (result != VK_SUCCESS) return;
2665 if (pDisplays) {
2666 for (uint32_t index = 0; index < *pDisplayCount; index++) {
2667 CreateObject(pDisplays[index], kVulkanObjectTypeDisplayKHR, nullptr);
2668 }
2669 }
2670
2671 }
2672
PreCallValidateCreateDisplayModeKHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,const VkDisplayModeCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDisplayModeKHR * pMode) const2673 bool ObjectLifetimes::PreCallValidateCreateDisplayModeKHR(
2674 VkPhysicalDevice physicalDevice,
2675 VkDisplayKHR display,
2676 const VkDisplayModeCreateInfoKHR* pCreateInfo,
2677 const VkAllocationCallbacks* pAllocator,
2678 VkDisplayModeKHR* pMode) const {
2679 bool skip = false;
2680 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkCreateDisplayModeKHR-physicalDevice-parameter", kVUIDUndefined);
2681 skip |= ValidateObject(display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkCreateDisplayModeKHR-display-parameter", "VUID-vkCreateDisplayModeKHR-display-parent");
2682
2683 return skip;
2684 }
2685
PostCallRecordCreateDisplayModeKHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,const VkDisplayModeCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDisplayModeKHR * pMode,VkResult result)2686 void ObjectLifetimes::PostCallRecordCreateDisplayModeKHR(
2687 VkPhysicalDevice physicalDevice,
2688 VkDisplayKHR display,
2689 const VkDisplayModeCreateInfoKHR* pCreateInfo,
2690 const VkAllocationCallbacks* pAllocator,
2691 VkDisplayModeKHR* pMode,
2692 VkResult result) {
2693 if (result != VK_SUCCESS) return;
2694 CreateObject(*pMode, kVulkanObjectTypeDisplayModeKHR, pAllocator);
2695
2696 }
2697
PreCallValidateGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,VkDisplayModeKHR mode,uint32_t planeIndex,VkDisplayPlaneCapabilitiesKHR * pCapabilities) const2698 bool ObjectLifetimes::PreCallValidateGetDisplayPlaneCapabilitiesKHR(
2699 VkPhysicalDevice physicalDevice,
2700 VkDisplayModeKHR mode,
2701 uint32_t planeIndex,
2702 VkDisplayPlaneCapabilitiesKHR* pCapabilities) const {
2703 bool skip = false;
2704 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter", kVUIDUndefined);
2705 skip |= ValidateObject(mode, kVulkanObjectTypeDisplayModeKHR, false, "VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter", kVUIDUndefined);
2706
2707 return skip;
2708 }
2709
PreCallValidateCreateDisplayPlaneSurfaceKHR(VkInstance instance,const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2710 bool ObjectLifetimes::PreCallValidateCreateDisplayPlaneSurfaceKHR(
2711 VkInstance instance,
2712 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
2713 const VkAllocationCallbacks* pAllocator,
2714 VkSurfaceKHR* pSurface) const {
2715 bool skip = false;
2716 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter", kVUIDUndefined);
2717 if (pCreateInfo) {
2718 skip |= ValidateObject(pCreateInfo->displayMode, kVulkanObjectTypeDisplayModeKHR, false, "VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter", kVUIDUndefined);
2719 }
2720
2721 return skip;
2722 }
2723
PostCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance,const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)2724 void ObjectLifetimes::PostCallRecordCreateDisplayPlaneSurfaceKHR(
2725 VkInstance instance,
2726 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
2727 const VkAllocationCallbacks* pAllocator,
2728 VkSurfaceKHR* pSurface,
2729 VkResult result) {
2730 if (result != VK_SUCCESS) return;
2731 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
2732
2733 }
2734
PreCallValidateCreateSharedSwapchainsKHR(VkDevice device,uint32_t swapchainCount,const VkSwapchainCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchains) const2735 bool ObjectLifetimes::PreCallValidateCreateSharedSwapchainsKHR(
2736 VkDevice device,
2737 uint32_t swapchainCount,
2738 const VkSwapchainCreateInfoKHR* pCreateInfos,
2739 const VkAllocationCallbacks* pAllocator,
2740 VkSwapchainKHR* pSwapchains) const {
2741 bool skip = false;
2742 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSharedSwapchainsKHR-device-parameter", kVUIDUndefined);
2743 if (pCreateInfos) {
2744 for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) {
2745 skip |= ValidateObject(pCreateInfos[index0].surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkSwapchainCreateInfoKHR-surface-parameter", "VUID-VkSwapchainCreateInfoKHR-commonparent");
2746 skip |= ValidateObject(pCreateInfos[index0].oldSwapchain, kVulkanObjectTypeSwapchainKHR, true, "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter", "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent");
2747 }
2748 }
2749
2750 return skip;
2751 }
2752
PostCallRecordCreateSharedSwapchainsKHR(VkDevice device,uint32_t swapchainCount,const VkSwapchainCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchains,VkResult result)2753 void ObjectLifetimes::PostCallRecordCreateSharedSwapchainsKHR(
2754 VkDevice device,
2755 uint32_t swapchainCount,
2756 const VkSwapchainCreateInfoKHR* pCreateInfos,
2757 const VkAllocationCallbacks* pAllocator,
2758 VkSwapchainKHR* pSwapchains,
2759 VkResult result) {
2760 if (result != VK_SUCCESS) return;
2761 if (pSwapchains) {
2762 for (uint32_t index = 0; index < swapchainCount; index++) {
2763 CreateObject(pSwapchains[index], kVulkanObjectTypeSwapchainKHR, pAllocator);
2764 }
2765 }
2766
2767 }
2768
2769 #ifdef VK_USE_PLATFORM_XLIB_KHR
2770
PreCallValidateCreateXlibSurfaceKHR(VkInstance instance,const VkXlibSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2771 bool ObjectLifetimes::PreCallValidateCreateXlibSurfaceKHR(
2772 VkInstance instance,
2773 const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
2774 const VkAllocationCallbacks* pAllocator,
2775 VkSurfaceKHR* pSurface) const {
2776 bool skip = false;
2777 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateXlibSurfaceKHR-instance-parameter", kVUIDUndefined);
2778
2779 return skip;
2780 }
2781
PostCallRecordCreateXlibSurfaceKHR(VkInstance instance,const VkXlibSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)2782 void ObjectLifetimes::PostCallRecordCreateXlibSurfaceKHR(
2783 VkInstance instance,
2784 const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
2785 const VkAllocationCallbacks* pAllocator,
2786 VkSurfaceKHR* pSurface,
2787 VkResult result) {
2788 if (result != VK_SUCCESS) return;
2789 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
2790
2791 }
2792 #endif // VK_USE_PLATFORM_XLIB_KHR
2793
2794 #ifdef VK_USE_PLATFORM_XLIB_KHR
2795
PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,Display * dpy,VisualID visualID) const2796 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(
2797 VkPhysicalDevice physicalDevice,
2798 uint32_t queueFamilyIndex,
2799 Display* dpy,
2800 VisualID visualID) const {
2801 bool skip = false;
2802 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
2803
2804 return skip;
2805 }
2806 #endif // VK_USE_PLATFORM_XLIB_KHR
2807
2808 #ifdef VK_USE_PLATFORM_XCB_KHR
2809
PreCallValidateCreateXcbSurfaceKHR(VkInstance instance,const VkXcbSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2810 bool ObjectLifetimes::PreCallValidateCreateXcbSurfaceKHR(
2811 VkInstance instance,
2812 const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
2813 const VkAllocationCallbacks* pAllocator,
2814 VkSurfaceKHR* pSurface) const {
2815 bool skip = false;
2816 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateXcbSurfaceKHR-instance-parameter", kVUIDUndefined);
2817
2818 return skip;
2819 }
2820
PostCallRecordCreateXcbSurfaceKHR(VkInstance instance,const VkXcbSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)2821 void ObjectLifetimes::PostCallRecordCreateXcbSurfaceKHR(
2822 VkInstance instance,
2823 const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
2824 const VkAllocationCallbacks* pAllocator,
2825 VkSurfaceKHR* pSurface,
2826 VkResult result) {
2827 if (result != VK_SUCCESS) return;
2828 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
2829
2830 }
2831 #endif // VK_USE_PLATFORM_XCB_KHR
2832
2833 #ifdef VK_USE_PLATFORM_XCB_KHR
2834
PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,xcb_connection_t * connection,xcb_visualid_t visual_id) const2835 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(
2836 VkPhysicalDevice physicalDevice,
2837 uint32_t queueFamilyIndex,
2838 xcb_connection_t* connection,
2839 xcb_visualid_t visual_id) const {
2840 bool skip = false;
2841 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
2842
2843 return skip;
2844 }
2845 #endif // VK_USE_PLATFORM_XCB_KHR
2846
2847 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
2848
PreCallValidateCreateWaylandSurfaceKHR(VkInstance instance,const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2849 bool ObjectLifetimes::PreCallValidateCreateWaylandSurfaceKHR(
2850 VkInstance instance,
2851 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
2852 const VkAllocationCallbacks* pAllocator,
2853 VkSurfaceKHR* pSurface) const {
2854 bool skip = false;
2855 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateWaylandSurfaceKHR-instance-parameter", kVUIDUndefined);
2856
2857 return skip;
2858 }
2859
PostCallRecordCreateWaylandSurfaceKHR(VkInstance instance,const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)2860 void ObjectLifetimes::PostCallRecordCreateWaylandSurfaceKHR(
2861 VkInstance instance,
2862 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
2863 const VkAllocationCallbacks* pAllocator,
2864 VkSurfaceKHR* pSurface,
2865 VkResult result) {
2866 if (result != VK_SUCCESS) return;
2867 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
2868
2869 }
2870 #endif // VK_USE_PLATFORM_WAYLAND_KHR
2871
2872 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
2873
PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,struct wl_display * display) const2874 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(
2875 VkPhysicalDevice physicalDevice,
2876 uint32_t queueFamilyIndex,
2877 struct wl_display* display) const {
2878 bool skip = false;
2879 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
2880
2881 return skip;
2882 }
2883 #endif // VK_USE_PLATFORM_WAYLAND_KHR
2884
2885 #ifdef VK_USE_PLATFORM_ANDROID_KHR
2886
PreCallValidateCreateAndroidSurfaceKHR(VkInstance instance,const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2887 bool ObjectLifetimes::PreCallValidateCreateAndroidSurfaceKHR(
2888 VkInstance instance,
2889 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
2890 const VkAllocationCallbacks* pAllocator,
2891 VkSurfaceKHR* pSurface) const {
2892 bool skip = false;
2893 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateAndroidSurfaceKHR-instance-parameter", kVUIDUndefined);
2894
2895 return skip;
2896 }
2897
PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance,const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)2898 void ObjectLifetimes::PostCallRecordCreateAndroidSurfaceKHR(
2899 VkInstance instance,
2900 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
2901 const VkAllocationCallbacks* pAllocator,
2902 VkSurfaceKHR* pSurface,
2903 VkResult result) {
2904 if (result != VK_SUCCESS) return;
2905 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
2906
2907 }
2908 #endif // VK_USE_PLATFORM_ANDROID_KHR
2909
2910 #ifdef VK_USE_PLATFORM_WIN32_KHR
2911
PreCallValidateCreateWin32SurfaceKHR(VkInstance instance,const VkWin32SurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2912 bool ObjectLifetimes::PreCallValidateCreateWin32SurfaceKHR(
2913 VkInstance instance,
2914 const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
2915 const VkAllocationCallbacks* pAllocator,
2916 VkSurfaceKHR* pSurface) const {
2917 bool skip = false;
2918 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateWin32SurfaceKHR-instance-parameter", kVUIDUndefined);
2919
2920 return skip;
2921 }
2922
PostCallRecordCreateWin32SurfaceKHR(VkInstance instance,const VkWin32SurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)2923 void ObjectLifetimes::PostCallRecordCreateWin32SurfaceKHR(
2924 VkInstance instance,
2925 const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
2926 const VkAllocationCallbacks* pAllocator,
2927 VkSurfaceKHR* pSurface,
2928 VkResult result) {
2929 if (result != VK_SUCCESS) return;
2930 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
2931
2932 }
2933 #endif // VK_USE_PLATFORM_WIN32_KHR
2934
2935 #ifdef VK_USE_PLATFORM_WIN32_KHR
2936
PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex) const2937 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(
2938 VkPhysicalDevice physicalDevice,
2939 uint32_t queueFamilyIndex) const {
2940 bool skip = false;
2941 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
2942
2943 return skip;
2944 }
2945 #endif // VK_USE_PLATFORM_WIN32_KHR
2946
PreCallValidateGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures) const2947 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFeatures2KHR(
2948 VkPhysicalDevice physicalDevice,
2949 VkPhysicalDeviceFeatures2* pFeatures) const {
2950 bool skip = false;
2951 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", kVUIDUndefined);
2952
2953 return skip;
2954 }
2955
PreCallValidateGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties) const2956 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceProperties2KHR(
2957 VkPhysicalDevice physicalDevice,
2958 VkPhysicalDeviceProperties2* pProperties) const {
2959 bool skip = false;
2960 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", kVUIDUndefined);
2961
2962 return skip;
2963 }
2964
PreCallValidateGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties) const2965 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFormatProperties2KHR(
2966 VkPhysicalDevice physicalDevice,
2967 VkFormat format,
2968 VkFormatProperties2* pFormatProperties) const {
2969 bool skip = false;
2970 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
2971
2972 return skip;
2973 }
2974
PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties) const2975 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(
2976 VkPhysicalDevice physicalDevice,
2977 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
2978 VkImageFormatProperties2* pImageFormatProperties) const {
2979 bool skip = false;
2980 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
2981
2982 return skip;
2983 }
2984
PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) const2985 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(
2986 VkPhysicalDevice physicalDevice,
2987 VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const {
2988 bool skip = false;
2989 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", kVUIDUndefined);
2990
2991 return skip;
2992 }
2993
PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties) const2994 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(
2995 VkPhysicalDevice physicalDevice,
2996 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
2997 uint32_t* pPropertyCount,
2998 VkSparseImageFormatProperties2* pProperties) const {
2999 bool skip = false;
3000 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
3001
3002 return skip;
3003 }
3004
PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) const3005 bool ObjectLifetimes::PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(
3006 VkDevice device,
3007 uint32_t heapIndex,
3008 uint32_t localDeviceIndex,
3009 uint32_t remoteDeviceIndex,
3010 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const {
3011 bool skip = false;
3012 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", kVUIDUndefined);
3013
3014 return skip;
3015 }
3016
PreCallValidateCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer,uint32_t deviceMask) const3017 bool ObjectLifetimes::PreCallValidateCmdSetDeviceMaskKHR(
3018 VkCommandBuffer commandBuffer,
3019 uint32_t deviceMask) const {
3020 bool skip = false;
3021 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDeviceMask-commandBuffer-parameter", kVUIDUndefined);
3022
3023 return skip;
3024 }
3025
PreCallValidateCmdDispatchBaseKHR(VkCommandBuffer commandBuffer,uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const3026 bool ObjectLifetimes::PreCallValidateCmdDispatchBaseKHR(
3027 VkCommandBuffer commandBuffer,
3028 uint32_t baseGroupX,
3029 uint32_t baseGroupY,
3030 uint32_t baseGroupZ,
3031 uint32_t groupCountX,
3032 uint32_t groupCountY,
3033 uint32_t groupCountZ) const {
3034 bool skip = false;
3035 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatchBase-commandBuffer-parameter", kVUIDUndefined);
3036
3037 return skip;
3038 }
3039
PreCallValidateTrimCommandPoolKHR(VkDevice device,VkCommandPool commandPool,VkCommandPoolTrimFlags flags) const3040 bool ObjectLifetimes::PreCallValidateTrimCommandPoolKHR(
3041 VkDevice device,
3042 VkCommandPool commandPool,
3043 VkCommandPoolTrimFlags flags) const {
3044 bool skip = false;
3045 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkTrimCommandPool-device-parameter", kVUIDUndefined);
3046 skip |= ValidateObject(commandPool, kVulkanObjectTypeCommandPool, false, "VUID-vkTrimCommandPool-commandPool-parameter", "VUID-vkTrimCommandPool-commandPool-parent");
3047
3048 return skip;
3049 }
3050
PreCallValidateEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) const3051 bool ObjectLifetimes::PreCallValidateEnumeratePhysicalDeviceGroupsKHR(
3052 VkInstance instance,
3053 uint32_t* pPhysicalDeviceGroupCount,
3054 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const {
3055 bool skip = false;
3056 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", kVUIDUndefined);
3057
3058 return skip;
3059 }
3060
PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties) const3061 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(
3062 VkPhysicalDevice physicalDevice,
3063 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
3064 VkExternalBufferProperties* pExternalBufferProperties) const {
3065 bool skip = false;
3066 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", kVUIDUndefined);
3067
3068 return skip;
3069 }
3070
3071 #ifdef VK_USE_PLATFORM_WIN32_KHR
3072
PreCallValidateGetMemoryWin32HandleKHR(VkDevice device,const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,HANDLE * pHandle) const3073 bool ObjectLifetimes::PreCallValidateGetMemoryWin32HandleKHR(
3074 VkDevice device,
3075 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
3076 HANDLE* pHandle) const {
3077 bool skip = false;
3078 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryWin32HandleKHR-device-parameter", kVUIDUndefined);
3079 if (pGetWin32HandleInfo) {
3080 skip |= ValidateObject(pGetWin32HandleInfo->memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter", kVUIDUndefined);
3081 }
3082
3083 return skip;
3084 }
3085 #endif // VK_USE_PLATFORM_WIN32_KHR
3086
3087 #ifdef VK_USE_PLATFORM_WIN32_KHR
3088
PreCallValidateGetMemoryWin32HandlePropertiesKHR(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,HANDLE handle,VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties) const3089 bool ObjectLifetimes::PreCallValidateGetMemoryWin32HandlePropertiesKHR(
3090 VkDevice device,
3091 VkExternalMemoryHandleTypeFlagBits handleType,
3092 HANDLE handle,
3093 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const {
3094 bool skip = false;
3095 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter", kVUIDUndefined);
3096
3097 return skip;
3098 }
3099 #endif // VK_USE_PLATFORM_WIN32_KHR
3100
PreCallValidateGetMemoryFdKHR(VkDevice device,const VkMemoryGetFdInfoKHR * pGetFdInfo,int * pFd) const3101 bool ObjectLifetimes::PreCallValidateGetMemoryFdKHR(
3102 VkDevice device,
3103 const VkMemoryGetFdInfoKHR* pGetFdInfo,
3104 int* pFd) const {
3105 bool skip = false;
3106 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryFdKHR-device-parameter", kVUIDUndefined);
3107 if (pGetFdInfo) {
3108 skip |= ValidateObject(pGetFdInfo->memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMemoryGetFdInfoKHR-memory-parameter", kVUIDUndefined);
3109 }
3110
3111 return skip;
3112 }
3113
PreCallValidateGetMemoryFdPropertiesKHR(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,int fd,VkMemoryFdPropertiesKHR * pMemoryFdProperties) const3114 bool ObjectLifetimes::PreCallValidateGetMemoryFdPropertiesKHR(
3115 VkDevice device,
3116 VkExternalMemoryHandleTypeFlagBits handleType,
3117 int fd,
3118 VkMemoryFdPropertiesKHR* pMemoryFdProperties) const {
3119 bool skip = false;
3120 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryFdPropertiesKHR-device-parameter", kVUIDUndefined);
3121
3122 return skip;
3123 }
3124
PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties) const3125 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(
3126 VkPhysicalDevice physicalDevice,
3127 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
3128 VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const {
3129 bool skip = false;
3130 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", kVUIDUndefined);
3131
3132 return skip;
3133 }
3134
3135 #ifdef VK_USE_PLATFORM_WIN32_KHR
3136
PreCallValidateImportSemaphoreWin32HandleKHR(VkDevice device,const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo) const3137 bool ObjectLifetimes::PreCallValidateImportSemaphoreWin32HandleKHR(
3138 VkDevice device,
3139 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) const {
3140 bool skip = false;
3141 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkImportSemaphoreWin32HandleKHR-device-parameter", kVUIDUndefined);
3142 if (pImportSemaphoreWin32HandleInfo) {
3143 skip |= ValidateObject(pImportSemaphoreWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter", kVUIDUndefined);
3144 }
3145
3146 return skip;
3147 }
3148 #endif // VK_USE_PLATFORM_WIN32_KHR
3149
3150 #ifdef VK_USE_PLATFORM_WIN32_KHR
3151
PreCallValidateGetSemaphoreWin32HandleKHR(VkDevice device,const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,HANDLE * pHandle) const3152 bool ObjectLifetimes::PreCallValidateGetSemaphoreWin32HandleKHR(
3153 VkDevice device,
3154 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
3155 HANDLE* pHandle) const {
3156 bool skip = false;
3157 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetSemaphoreWin32HandleKHR-device-parameter", kVUIDUndefined);
3158 if (pGetWin32HandleInfo) {
3159 skip |= ValidateObject(pGetWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter", kVUIDUndefined);
3160 }
3161
3162 return skip;
3163 }
3164 #endif // VK_USE_PLATFORM_WIN32_KHR
3165
PreCallValidateImportSemaphoreFdKHR(VkDevice device,const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo) const3166 bool ObjectLifetimes::PreCallValidateImportSemaphoreFdKHR(
3167 VkDevice device,
3168 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const {
3169 bool skip = false;
3170 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkImportSemaphoreFdKHR-device-parameter", kVUIDUndefined);
3171 if (pImportSemaphoreFdInfo) {
3172 skip |= ValidateObject(pImportSemaphoreFdInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter", kVUIDUndefined);
3173 }
3174
3175 return skip;
3176 }
3177
PreCallValidateGetSemaphoreFdKHR(VkDevice device,const VkSemaphoreGetFdInfoKHR * pGetFdInfo,int * pFd) const3178 bool ObjectLifetimes::PreCallValidateGetSemaphoreFdKHR(
3179 VkDevice device,
3180 const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
3181 int* pFd) const {
3182 bool skip = false;
3183 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetSemaphoreFdKHR-device-parameter", kVUIDUndefined);
3184 if (pGetFdInfo) {
3185 skip |= ValidateObject(pGetFdInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter", kVUIDUndefined);
3186 }
3187
3188 return skip;
3189 }
3190
PreCallValidateCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,VkDescriptorUpdateTemplate descriptorUpdateTemplate,VkPipelineLayout layout,uint32_t set,const void * pData) const3191 bool ObjectLifetimes::PreCallValidateCmdPushDescriptorSetWithTemplateKHR(
3192 VkCommandBuffer commandBuffer,
3193 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
3194 VkPipelineLayout layout,
3195 uint32_t set,
3196 const void* pData) const {
3197 bool skip = false;
3198 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter", "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent");
3199 skip |= ValidateObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, "VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter", "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent");
3200 skip |= ValidateObject(layout, kVulkanObjectTypePipelineLayout, false, "VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter", "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent");
3201
3202 return skip;
3203 }
3204
PreCallValidateDestroyDescriptorUpdateTemplateKHR(VkDevice device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const VkAllocationCallbacks * pAllocator) const3205 bool ObjectLifetimes::PreCallValidateDestroyDescriptorUpdateTemplateKHR(
3206 VkDevice device,
3207 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
3208 const VkAllocationCallbacks* pAllocator) const {
3209 bool skip = false;
3210 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", kVUIDUndefined);
3211 skip |= ValidateObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, true, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent");
3212 skip |= ValidateDestroyObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357");
3213
3214 return skip;
3215 }
3216
PreCallRecordDestroyDescriptorUpdateTemplateKHR(VkDevice device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const VkAllocationCallbacks * pAllocator)3217 void ObjectLifetimes::PreCallRecordDestroyDescriptorUpdateTemplateKHR(
3218 VkDevice device,
3219 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
3220 const VkAllocationCallbacks* pAllocator) {
3221 RecordDestroyObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate);
3222
3223 }
3224
PreCallValidateUpdateDescriptorSetWithTemplateKHR(VkDevice device,VkDescriptorSet descriptorSet,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData) const3225 bool ObjectLifetimes::PreCallValidateUpdateDescriptorSetWithTemplateKHR(
3226 VkDevice device,
3227 VkDescriptorSet descriptorSet,
3228 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
3229 const void* pData) const {
3230 bool skip = false;
3231 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSetWithTemplate-device-parameter", kVUIDUndefined);
3232 skip |= ValidateObject(descriptorSet, kVulkanObjectTypeDescriptorSet, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter", kVUIDUndefined);
3233 skip |= ValidateObject(descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter", "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent");
3234
3235 return skip;
3236 }
3237
PreCallValidateCreateRenderPass2KHR(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const3238 bool ObjectLifetimes::PreCallValidateCreateRenderPass2KHR(
3239 VkDevice device,
3240 const VkRenderPassCreateInfo2* pCreateInfo,
3241 const VkAllocationCallbacks* pAllocator,
3242 VkRenderPass* pRenderPass) const {
3243 bool skip = false;
3244 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRenderPass2-device-parameter", kVUIDUndefined);
3245
3246 return skip;
3247 }
3248
PostCallRecordCreateRenderPass2KHR(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass,VkResult result)3249 void ObjectLifetimes::PostCallRecordCreateRenderPass2KHR(
3250 VkDevice device,
3251 const VkRenderPassCreateInfo2* pCreateInfo,
3252 const VkAllocationCallbacks* pAllocator,
3253 VkRenderPass* pRenderPass,
3254 VkResult result) {
3255 if (result != VK_SUCCESS) return;
3256 CreateObject(*pRenderPass, kVulkanObjectTypeRenderPass, pAllocator);
3257
3258 }
3259
PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,const VkSubpassBeginInfo * pSubpassBeginInfo) const3260 bool ObjectLifetimes::PreCallValidateCmdBeginRenderPass2KHR(
3261 VkCommandBuffer commandBuffer,
3262 const VkRenderPassBeginInfo* pRenderPassBegin,
3263 const VkSubpassBeginInfo* pSubpassBeginInfo) const {
3264 bool skip = false;
3265 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginRenderPass2-commandBuffer-parameter", kVUIDUndefined);
3266 if (pRenderPassBegin) {
3267 skip |= ValidateObject(pRenderPassBegin->renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkRenderPassBeginInfo-renderPass-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
3268 skip |= ValidateObject(pRenderPassBegin->framebuffer, kVulkanObjectTypeFramebuffer, false, "VUID-VkRenderPassBeginInfo-framebuffer-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
3269 }
3270
3271 return skip;
3272 }
3273
PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,const VkSubpassBeginInfo * pSubpassBeginInfo,const VkSubpassEndInfo * pSubpassEndInfo) const3274 bool ObjectLifetimes::PreCallValidateCmdNextSubpass2KHR(
3275 VkCommandBuffer commandBuffer,
3276 const VkSubpassBeginInfo* pSubpassBeginInfo,
3277 const VkSubpassEndInfo* pSubpassEndInfo) const {
3278 bool skip = false;
3279 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdNextSubpass2-commandBuffer-parameter", kVUIDUndefined);
3280
3281 return skip;
3282 }
3283
PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,const VkSubpassEndInfo * pSubpassEndInfo) const3284 bool ObjectLifetimes::PreCallValidateCmdEndRenderPass2KHR(
3285 VkCommandBuffer commandBuffer,
3286 const VkSubpassEndInfo* pSubpassEndInfo) const {
3287 bool skip = false;
3288 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndRenderPass2-commandBuffer-parameter", kVUIDUndefined);
3289
3290 return skip;
3291 }
3292
PreCallValidateGetSwapchainStatusKHR(VkDevice device,VkSwapchainKHR swapchain) const3293 bool ObjectLifetimes::PreCallValidateGetSwapchainStatusKHR(
3294 VkDevice device,
3295 VkSwapchainKHR swapchain) const {
3296 bool skip = false;
3297 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetSwapchainStatusKHR-device-parameter", "VUID-vkGetSwapchainStatusKHR-commonparent");
3298 skip |= ValidateObject(swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetSwapchainStatusKHR-swapchain-parameter", "VUID-vkGetSwapchainStatusKHR-commonparent");
3299
3300 return skip;
3301 }
3302
PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties) const3303 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(
3304 VkPhysicalDevice physicalDevice,
3305 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
3306 VkExternalFenceProperties* pExternalFenceProperties) const {
3307 bool skip = false;
3308 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", kVUIDUndefined);
3309
3310 return skip;
3311 }
3312
3313 #ifdef VK_USE_PLATFORM_WIN32_KHR
3314
PreCallValidateImportFenceWin32HandleKHR(VkDevice device,const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo) const3315 bool ObjectLifetimes::PreCallValidateImportFenceWin32HandleKHR(
3316 VkDevice device,
3317 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) const {
3318 bool skip = false;
3319 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkImportFenceWin32HandleKHR-device-parameter", kVUIDUndefined);
3320 if (pImportFenceWin32HandleInfo) {
3321 skip |= ValidateObject(pImportFenceWin32HandleInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter", kVUIDUndefined);
3322 }
3323
3324 return skip;
3325 }
3326 #endif // VK_USE_PLATFORM_WIN32_KHR
3327
3328 #ifdef VK_USE_PLATFORM_WIN32_KHR
3329
PreCallValidateGetFenceWin32HandleKHR(VkDevice device,const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,HANDLE * pHandle) const3330 bool ObjectLifetimes::PreCallValidateGetFenceWin32HandleKHR(
3331 VkDevice device,
3332 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
3333 HANDLE* pHandle) const {
3334 bool skip = false;
3335 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetFenceWin32HandleKHR-device-parameter", kVUIDUndefined);
3336 if (pGetWin32HandleInfo) {
3337 skip |= ValidateObject(pGetWin32HandleInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter", kVUIDUndefined);
3338 }
3339
3340 return skip;
3341 }
3342 #endif // VK_USE_PLATFORM_WIN32_KHR
3343
PreCallValidateImportFenceFdKHR(VkDevice device,const VkImportFenceFdInfoKHR * pImportFenceFdInfo) const3344 bool ObjectLifetimes::PreCallValidateImportFenceFdKHR(
3345 VkDevice device,
3346 const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const {
3347 bool skip = false;
3348 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkImportFenceFdKHR-device-parameter", kVUIDUndefined);
3349 if (pImportFenceFdInfo) {
3350 skip |= ValidateObject(pImportFenceFdInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkImportFenceFdInfoKHR-fence-parameter", kVUIDUndefined);
3351 }
3352
3353 return skip;
3354 }
3355
PreCallValidateGetFenceFdKHR(VkDevice device,const VkFenceGetFdInfoKHR * pGetFdInfo,int * pFd) const3356 bool ObjectLifetimes::PreCallValidateGetFenceFdKHR(
3357 VkDevice device,
3358 const VkFenceGetFdInfoKHR* pGetFdInfo,
3359 int* pFd) const {
3360 bool skip = false;
3361 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetFenceFdKHR-device-parameter", kVUIDUndefined);
3362 if (pGetFdInfo) {
3363 skip |= ValidateObject(pGetFdInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkFenceGetFdInfoKHR-fence-parameter", kVUIDUndefined);
3364 }
3365
3366 return skip;
3367 }
3368
PreCallValidateEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,uint32_t * pCounterCount,VkPerformanceCounterKHR * pCounters,VkPerformanceCounterDescriptionKHR * pCounterDescriptions) const3369 bool ObjectLifetimes::PreCallValidateEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
3370 VkPhysicalDevice physicalDevice,
3371 uint32_t queueFamilyIndex,
3372 uint32_t* pCounterCount,
3373 VkPerformanceCounterKHR* pCounters,
3374 VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const {
3375 bool skip = false;
3376 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter", kVUIDUndefined);
3377
3378 return skip;
3379 }
3380
PreCallValidateGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice,const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,uint32_t * pNumPasses) const3381 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
3382 VkPhysicalDevice physicalDevice,
3383 const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
3384 uint32_t* pNumPasses) const {
3385 bool skip = false;
3386 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter", kVUIDUndefined);
3387
3388 return skip;
3389 }
3390
PreCallValidateAcquireProfilingLockKHR(VkDevice device,const VkAcquireProfilingLockInfoKHR * pInfo) const3391 bool ObjectLifetimes::PreCallValidateAcquireProfilingLockKHR(
3392 VkDevice device,
3393 const VkAcquireProfilingLockInfoKHR* pInfo) const {
3394 bool skip = false;
3395 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkAcquireProfilingLockKHR-device-parameter", kVUIDUndefined);
3396
3397 return skip;
3398 }
3399
PreCallValidateReleaseProfilingLockKHR(VkDevice device) const3400 bool ObjectLifetimes::PreCallValidateReleaseProfilingLockKHR(
3401 VkDevice device) const {
3402 bool skip = false;
3403 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkReleaseProfilingLockKHR-device-parameter", kVUIDUndefined);
3404
3405 return skip;
3406 }
3407
PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,VkSurfaceCapabilities2KHR * pSurfaceCapabilities) const3408 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(
3409 VkPhysicalDevice physicalDevice,
3410 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
3411 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const {
3412 bool skip = false;
3413 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter", kVUIDUndefined);
3414 if (pSurfaceInfo) {
3415 skip |= ValidateObject(pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
3416 }
3417
3418 return skip;
3419 }
3420
PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,uint32_t * pSurfaceFormatCount,VkSurfaceFormat2KHR * pSurfaceFormats) const3421 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(
3422 VkPhysicalDevice physicalDevice,
3423 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
3424 uint32_t* pSurfaceFormatCount,
3425 VkSurfaceFormat2KHR* pSurfaceFormats) const {
3426 bool skip = false;
3427 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter", kVUIDUndefined);
3428 if (pSurfaceInfo) {
3429 skip |= ValidateObject(pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
3430 }
3431
3432 return skip;
3433 }
3434
PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPlaneProperties2KHR * pProperties) const3435 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(
3436 VkPhysicalDevice physicalDevice,
3437 uint32_t* pPropertyCount,
3438 VkDisplayPlaneProperties2KHR* pProperties) const {
3439 bool skip = false;
3440 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
3441
3442 return skip;
3443 }
3444
PreCallValidateGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo,VkDisplayPlaneCapabilities2KHR * pCapabilities) const3445 bool ObjectLifetimes::PreCallValidateGetDisplayPlaneCapabilities2KHR(
3446 VkPhysicalDevice physicalDevice,
3447 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
3448 VkDisplayPlaneCapabilities2KHR* pCapabilities) const {
3449 bool skip = false;
3450 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter", kVUIDUndefined);
3451 if (pDisplayPlaneInfo) {
3452 skip |= ValidateObject(pDisplayPlaneInfo->mode, kVulkanObjectTypeDisplayModeKHR, false, "VUID-VkDisplayPlaneInfo2KHR-mode-parameter", kVUIDUndefined);
3453 }
3454
3455 return skip;
3456 }
3457
PreCallValidateGetImageMemoryRequirements2KHR(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const3458 bool ObjectLifetimes::PreCallValidateGetImageMemoryRequirements2KHR(
3459 VkDevice device,
3460 const VkImageMemoryRequirementsInfo2* pInfo,
3461 VkMemoryRequirements2* pMemoryRequirements) const {
3462 bool skip = false;
3463 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageMemoryRequirements2-device-parameter", kVUIDUndefined);
3464 if (pInfo) {
3465 skip |= ValidateObject(pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
3466 }
3467
3468 return skip;
3469 }
3470
PreCallValidateGetBufferMemoryRequirements2KHR(VkDevice device,const VkBufferMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const3471 bool ObjectLifetimes::PreCallValidateGetBufferMemoryRequirements2KHR(
3472 VkDevice device,
3473 const VkBufferMemoryRequirementsInfo2* pInfo,
3474 VkMemoryRequirements2* pMemoryRequirements) const {
3475 bool skip = false;
3476 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferMemoryRequirements2-device-parameter", kVUIDUndefined);
3477 if (pInfo) {
3478 skip |= ValidateObject(pInfo->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", kVUIDUndefined);
3479 }
3480
3481 return skip;
3482 }
3483
PreCallValidateGetImageSparseMemoryRequirements2KHR(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) const3484 bool ObjectLifetimes::PreCallValidateGetImageSparseMemoryRequirements2KHR(
3485 VkDevice device,
3486 const VkImageSparseMemoryRequirementsInfo2* pInfo,
3487 uint32_t* pSparseMemoryRequirementCount,
3488 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const {
3489 bool skip = false;
3490 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSparseMemoryRequirements2-device-parameter", kVUIDUndefined);
3491 if (pInfo) {
3492 skip |= ValidateObject(pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
3493 }
3494
3495 return skip;
3496 }
3497
PreCallValidateCreateSamplerYcbcrConversionKHR(VkDevice device,const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSamplerYcbcrConversion * pYcbcrConversion) const3498 bool ObjectLifetimes::PreCallValidateCreateSamplerYcbcrConversionKHR(
3499 VkDevice device,
3500 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
3501 const VkAllocationCallbacks* pAllocator,
3502 VkSamplerYcbcrConversion* pYcbcrConversion) const {
3503 bool skip = false;
3504 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSamplerYcbcrConversion-device-parameter", kVUIDUndefined);
3505
3506 return skip;
3507 }
3508
PostCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device,const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSamplerYcbcrConversion * pYcbcrConversion,VkResult result)3509 void ObjectLifetimes::PostCallRecordCreateSamplerYcbcrConversionKHR(
3510 VkDevice device,
3511 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
3512 const VkAllocationCallbacks* pAllocator,
3513 VkSamplerYcbcrConversion* pYcbcrConversion,
3514 VkResult result) {
3515 if (result != VK_SUCCESS) return;
3516 CreateObject(*pYcbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator);
3517
3518 }
3519
PreCallValidateDestroySamplerYcbcrConversionKHR(VkDevice device,VkSamplerYcbcrConversion ycbcrConversion,const VkAllocationCallbacks * pAllocator) const3520 bool ObjectLifetimes::PreCallValidateDestroySamplerYcbcrConversionKHR(
3521 VkDevice device,
3522 VkSamplerYcbcrConversion ycbcrConversion,
3523 const VkAllocationCallbacks* pAllocator) const {
3524 bool skip = false;
3525 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySamplerYcbcrConversion-device-parameter", kVUIDUndefined);
3526 skip |= ValidateObject(ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, true, "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent");
3527 skip |= ValidateDestroyObject(ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator, kVUIDUndefined, kVUIDUndefined);
3528
3529 return skip;
3530 }
3531
PreCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device,VkSamplerYcbcrConversion ycbcrConversion,const VkAllocationCallbacks * pAllocator)3532 void ObjectLifetimes::PreCallRecordDestroySamplerYcbcrConversionKHR(
3533 VkDevice device,
3534 VkSamplerYcbcrConversion ycbcrConversion,
3535 const VkAllocationCallbacks* pAllocator) {
3536 RecordDestroyObject(ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion);
3537
3538 }
3539
PreCallValidateBindBufferMemory2KHR(VkDevice device,uint32_t bindInfoCount,const VkBindBufferMemoryInfo * pBindInfos) const3540 bool ObjectLifetimes::PreCallValidateBindBufferMemory2KHR(
3541 VkDevice device,
3542 uint32_t bindInfoCount,
3543 const VkBindBufferMemoryInfo* pBindInfos) const {
3544 bool skip = false;
3545 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindBufferMemory2-device-parameter", kVUIDUndefined);
3546 if (pBindInfos) {
3547 for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
3548 skip |= ValidateObject(pBindInfos[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBindBufferMemoryInfo-buffer-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
3549 skip |= ValidateObject(pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkBindBufferMemoryInfo-memory-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
3550 }
3551 }
3552
3553 return skip;
3554 }
3555
PreCallValidateBindImageMemory2KHR(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos) const3556 bool ObjectLifetimes::PreCallValidateBindImageMemory2KHR(
3557 VkDevice device,
3558 uint32_t bindInfoCount,
3559 const VkBindImageMemoryInfo* pBindInfos) const {
3560 bool skip = false;
3561 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindImageMemory2-device-parameter", kVUIDUndefined);
3562 if (pBindInfos) {
3563 for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
3564 skip |= ValidateObject(pBindInfos[index0].image, kVulkanObjectTypeImage, false, "VUID-VkBindImageMemoryInfo-image-parameter", "VUID-VkBindImageMemoryInfo-commonparent");
3565 skip |= ValidateObject(pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, true, kVUIDUndefined, "VUID-VkBindImageMemoryInfo-commonparent");
3566 }
3567 }
3568
3569 return skip;
3570 }
3571
PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const3572 bool ObjectLifetimes::PreCallValidateCmdDrawIndirectCountKHR(
3573 VkCommandBuffer commandBuffer,
3574 VkBuffer buffer,
3575 VkDeviceSize offset,
3576 VkBuffer countBuffer,
3577 VkDeviceSize countBufferOffset,
3578 uint32_t maxDrawCount,
3579 uint32_t stride) const {
3580 bool skip = false;
3581 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirectCount-commandBuffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
3582 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCount-buffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
3583 skip |= ValidateObject(countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCount-countBuffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
3584
3585 return skip;
3586 }
3587
PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const3588 bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirectCountKHR(
3589 VkCommandBuffer commandBuffer,
3590 VkBuffer buffer,
3591 VkDeviceSize offset,
3592 VkBuffer countBuffer,
3593 VkDeviceSize countBufferOffset,
3594 uint32_t maxDrawCount,
3595 uint32_t stride) const {
3596 bool skip = false;
3597 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
3598 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-buffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
3599 skip |= ValidateObject(countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
3600
3601 return skip;
3602 }
3603
PreCallValidateGetSemaphoreCounterValueKHR(VkDevice device,VkSemaphore semaphore,uint64_t * pValue) const3604 bool ObjectLifetimes::PreCallValidateGetSemaphoreCounterValueKHR(
3605 VkDevice device,
3606 VkSemaphore semaphore,
3607 uint64_t* pValue) const {
3608 bool skip = false;
3609 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetSemaphoreCounterValue-device-parameter", kVUIDUndefined);
3610 skip |= ValidateObject(semaphore, kVulkanObjectTypeSemaphore, false, "VUID-vkGetSemaphoreCounterValue-semaphore-parameter", "VUID-vkGetSemaphoreCounterValue-semaphore-parent");
3611
3612 return skip;
3613 }
3614
PreCallValidateWaitSemaphoresKHR(VkDevice device,const VkSemaphoreWaitInfo * pWaitInfo,uint64_t timeout) const3615 bool ObjectLifetimes::PreCallValidateWaitSemaphoresKHR(
3616 VkDevice device,
3617 const VkSemaphoreWaitInfo* pWaitInfo,
3618 uint64_t timeout) const {
3619 bool skip = false;
3620 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkWaitSemaphores-device-parameter", kVUIDUndefined);
3621 if (pWaitInfo) {
3622 if (pWaitInfo->pSemaphores) {
3623 for (uint32_t index1 = 0; index1 < pWaitInfo->semaphoreCount; ++index1) {
3624 skip |= ValidateObject(pWaitInfo->pSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreWaitInfo-pSemaphores-parameter", kVUIDUndefined);
3625 }
3626 }
3627 }
3628
3629 return skip;
3630 }
3631
PreCallValidateSignalSemaphoreKHR(VkDevice device,const VkSemaphoreSignalInfo * pSignalInfo) const3632 bool ObjectLifetimes::PreCallValidateSignalSemaphoreKHR(
3633 VkDevice device,
3634 const VkSemaphoreSignalInfo* pSignalInfo) const {
3635 bool skip = false;
3636 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkSignalSemaphore-device-parameter", kVUIDUndefined);
3637 if (pSignalInfo) {
3638 skip |= ValidateObject(pSignalInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreSignalInfo-semaphore-parameter", kVUIDUndefined);
3639 }
3640
3641 return skip;
3642 }
3643
PreCallValidateGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates) const3644 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFragmentShadingRatesKHR(
3645 VkPhysicalDevice physicalDevice,
3646 uint32_t* pFragmentShadingRateCount,
3647 VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) const {
3648 bool skip = false;
3649 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-physicalDevice-parameter", kVUIDUndefined);
3650
3651 return skip;
3652 }
3653
PreCallValidateCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,const VkExtent2D * pFragmentSize,const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const3654 bool ObjectLifetimes::PreCallValidateCmdSetFragmentShadingRateKHR(
3655 VkCommandBuffer commandBuffer,
3656 const VkExtent2D* pFragmentSize,
3657 const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const {
3658 bool skip = false;
3659 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetFragmentShadingRateKHR-commandBuffer-parameter", kVUIDUndefined);
3660
3661 return skip;
3662 }
3663
PreCallValidateGetBufferDeviceAddressKHR(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const3664 bool ObjectLifetimes::PreCallValidateGetBufferDeviceAddressKHR(
3665 VkDevice device,
3666 const VkBufferDeviceAddressInfo* pInfo) const {
3667 bool skip = false;
3668 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferDeviceAddress-device-parameter", kVUIDUndefined);
3669
3670 return skip;
3671 }
3672
PreCallValidateGetBufferOpaqueCaptureAddressKHR(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const3673 bool ObjectLifetimes::PreCallValidateGetBufferOpaqueCaptureAddressKHR(
3674 VkDevice device,
3675 const VkBufferDeviceAddressInfo* pInfo) const {
3676 bool skip = false;
3677 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferOpaqueCaptureAddress-device-parameter", kVUIDUndefined);
3678
3679 return skip;
3680 }
3681
PreCallValidateGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo) const3682 bool ObjectLifetimes::PreCallValidateGetDeviceMemoryOpaqueCaptureAddressKHR(
3683 VkDevice device,
3684 const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const {
3685 bool skip = false;
3686 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceMemoryOpaqueCaptureAddress-device-parameter", kVUIDUndefined);
3687
3688 return skip;
3689 }
3690
3691 #ifdef VK_ENABLE_BETA_EXTENSIONS
3692
PreCallValidateCreateDeferredOperationKHR(VkDevice device,const VkAllocationCallbacks * pAllocator,VkDeferredOperationKHR * pDeferredOperation) const3693 bool ObjectLifetimes::PreCallValidateCreateDeferredOperationKHR(
3694 VkDevice device,
3695 const VkAllocationCallbacks* pAllocator,
3696 VkDeferredOperationKHR* pDeferredOperation) const {
3697 bool skip = false;
3698 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateDeferredOperationKHR-device-parameter", kVUIDUndefined);
3699
3700 return skip;
3701 }
3702
PostCallRecordCreateDeferredOperationKHR(VkDevice device,const VkAllocationCallbacks * pAllocator,VkDeferredOperationKHR * pDeferredOperation,VkResult result)3703 void ObjectLifetimes::PostCallRecordCreateDeferredOperationKHR(
3704 VkDevice device,
3705 const VkAllocationCallbacks* pAllocator,
3706 VkDeferredOperationKHR* pDeferredOperation,
3707 VkResult result) {
3708 if (result != VK_SUCCESS) return;
3709 CreateObject(*pDeferredOperation, kVulkanObjectTypeDeferredOperationKHR, pAllocator);
3710
3711 }
3712 #endif // VK_ENABLE_BETA_EXTENSIONS
3713
3714 #ifdef VK_ENABLE_BETA_EXTENSIONS
3715
PreCallValidateDestroyDeferredOperationKHR(VkDevice device,VkDeferredOperationKHR operation,const VkAllocationCallbacks * pAllocator) const3716 bool ObjectLifetimes::PreCallValidateDestroyDeferredOperationKHR(
3717 VkDevice device,
3718 VkDeferredOperationKHR operation,
3719 const VkAllocationCallbacks* pAllocator) const {
3720 bool skip = false;
3721 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDeferredOperationKHR-device-parameter", kVUIDUndefined);
3722 skip |= ValidateObject(operation, kVulkanObjectTypeDeferredOperationKHR, true, "VUID-vkDestroyDeferredOperationKHR-operation-parameter", "VUID-vkDestroyDeferredOperationKHR-operation-parent");
3723 skip |= ValidateDestroyObject(operation, kVulkanObjectTypeDeferredOperationKHR, pAllocator, kVUIDUndefined, kVUIDUndefined);
3724
3725 return skip;
3726 }
3727
PreCallRecordDestroyDeferredOperationKHR(VkDevice device,VkDeferredOperationKHR operation,const VkAllocationCallbacks * pAllocator)3728 void ObjectLifetimes::PreCallRecordDestroyDeferredOperationKHR(
3729 VkDevice device,
3730 VkDeferredOperationKHR operation,
3731 const VkAllocationCallbacks* pAllocator) {
3732 RecordDestroyObject(operation, kVulkanObjectTypeDeferredOperationKHR);
3733
3734 }
3735 #endif // VK_ENABLE_BETA_EXTENSIONS
3736
3737 #ifdef VK_ENABLE_BETA_EXTENSIONS
3738
PreCallValidateGetDeferredOperationMaxConcurrencyKHR(VkDevice device,VkDeferredOperationKHR operation) const3739 bool ObjectLifetimes::PreCallValidateGetDeferredOperationMaxConcurrencyKHR(
3740 VkDevice device,
3741 VkDeferredOperationKHR operation) const {
3742 bool skip = false;
3743 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeferredOperationMaxConcurrencyKHR-device-parameter", kVUIDUndefined);
3744 skip |= ValidateObject(operation, kVulkanObjectTypeDeferredOperationKHR, false, "VUID-vkGetDeferredOperationMaxConcurrencyKHR-operation-parameter", "VUID-vkGetDeferredOperationMaxConcurrencyKHR-operation-parent");
3745
3746 return skip;
3747 }
3748 #endif // VK_ENABLE_BETA_EXTENSIONS
3749
3750 #ifdef VK_ENABLE_BETA_EXTENSIONS
3751
PreCallValidateGetDeferredOperationResultKHR(VkDevice device,VkDeferredOperationKHR operation) const3752 bool ObjectLifetimes::PreCallValidateGetDeferredOperationResultKHR(
3753 VkDevice device,
3754 VkDeferredOperationKHR operation) const {
3755 bool skip = false;
3756 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeferredOperationResultKHR-device-parameter", kVUIDUndefined);
3757 skip |= ValidateObject(operation, kVulkanObjectTypeDeferredOperationKHR, false, "VUID-vkGetDeferredOperationResultKHR-operation-parameter", "VUID-vkGetDeferredOperationResultKHR-operation-parent");
3758
3759 return skip;
3760 }
3761 #endif // VK_ENABLE_BETA_EXTENSIONS
3762
3763 #ifdef VK_ENABLE_BETA_EXTENSIONS
3764
PreCallValidateDeferredOperationJoinKHR(VkDevice device,VkDeferredOperationKHR operation) const3765 bool ObjectLifetimes::PreCallValidateDeferredOperationJoinKHR(
3766 VkDevice device,
3767 VkDeferredOperationKHR operation) const {
3768 bool skip = false;
3769 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDeferredOperationJoinKHR-device-parameter", kVUIDUndefined);
3770 skip |= ValidateObject(operation, kVulkanObjectTypeDeferredOperationKHR, false, "VUID-vkDeferredOperationJoinKHR-operation-parameter", "VUID-vkDeferredOperationJoinKHR-operation-parent");
3771
3772 return skip;
3773 }
3774 #endif // VK_ENABLE_BETA_EXTENSIONS
3775
PreCallValidateGetPipelineExecutablePropertiesKHR(VkDevice device,const VkPipelineInfoKHR * pPipelineInfo,uint32_t * pExecutableCount,VkPipelineExecutablePropertiesKHR * pProperties) const3776 bool ObjectLifetimes::PreCallValidateGetPipelineExecutablePropertiesKHR(
3777 VkDevice device,
3778 const VkPipelineInfoKHR* pPipelineInfo,
3779 uint32_t* pExecutableCount,
3780 VkPipelineExecutablePropertiesKHR* pProperties) const {
3781 bool skip = false;
3782 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter", kVUIDUndefined);
3783 if (pPipelineInfo) {
3784 skip |= ValidateObject(pPipelineInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineInfoKHR-pipeline-parameter", kVUIDUndefined);
3785 }
3786
3787 return skip;
3788 }
3789
PreCallValidateGetPipelineExecutableStatisticsKHR(VkDevice device,const VkPipelineExecutableInfoKHR * pExecutableInfo,uint32_t * pStatisticCount,VkPipelineExecutableStatisticKHR * pStatistics) const3790 bool ObjectLifetimes::PreCallValidateGetPipelineExecutableStatisticsKHR(
3791 VkDevice device,
3792 const VkPipelineExecutableInfoKHR* pExecutableInfo,
3793 uint32_t* pStatisticCount,
3794 VkPipelineExecutableStatisticKHR* pStatistics) const {
3795 bool skip = false;
3796 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter", kVUIDUndefined);
3797 if (pExecutableInfo) {
3798 skip |= ValidateObject(pExecutableInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineExecutableInfoKHR-pipeline-parameter", kVUIDUndefined);
3799 }
3800
3801 return skip;
3802 }
3803
PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(VkDevice device,const VkPipelineExecutableInfoKHR * pExecutableInfo,uint32_t * pInternalRepresentationCount,VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations) const3804 bool ObjectLifetimes::PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
3805 VkDevice device,
3806 const VkPipelineExecutableInfoKHR* pExecutableInfo,
3807 uint32_t* pInternalRepresentationCount,
3808 VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const {
3809 bool skip = false;
3810 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter", kVUIDUndefined);
3811 if (pExecutableInfo) {
3812 skip |= ValidateObject(pExecutableInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineExecutableInfoKHR-pipeline-parameter", kVUIDUndefined);
3813 }
3814
3815 return skip;
3816 }
3817
PreCallValidateCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,const VkCopyBufferInfo2KHR * pCopyBufferInfo) const3818 bool ObjectLifetimes::PreCallValidateCmdCopyBuffer2KHR(
3819 VkCommandBuffer commandBuffer,
3820 const VkCopyBufferInfo2KHR* pCopyBufferInfo) const {
3821 bool skip = false;
3822 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyBuffer2KHR-commandBuffer-parameter", kVUIDUndefined);
3823 if (pCopyBufferInfo) {
3824 skip |= ValidateObject(pCopyBufferInfo->srcBuffer, kVulkanObjectTypeBuffer, false, "VUID-VkCopyBufferInfo2KHR-srcBuffer-parameter", "VUID-VkCopyBufferInfo2KHR-commonparent");
3825 skip |= ValidateObject(pCopyBufferInfo->dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-VkCopyBufferInfo2KHR-dstBuffer-parameter", "VUID-VkCopyBufferInfo2KHR-commonparent");
3826 }
3827
3828 return skip;
3829 }
3830
PreCallValidateCmdCopyImage2KHR(VkCommandBuffer commandBuffer,const VkCopyImageInfo2KHR * pCopyImageInfo) const3831 bool ObjectLifetimes::PreCallValidateCmdCopyImage2KHR(
3832 VkCommandBuffer commandBuffer,
3833 const VkCopyImageInfo2KHR* pCopyImageInfo) const {
3834 bool skip = false;
3835 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyImage2KHR-commandBuffer-parameter", kVUIDUndefined);
3836 if (pCopyImageInfo) {
3837 skip |= ValidateObject(pCopyImageInfo->srcImage, kVulkanObjectTypeImage, false, "VUID-VkCopyImageInfo2KHR-srcImage-parameter", "VUID-VkCopyImageInfo2KHR-commonparent");
3838 skip |= ValidateObject(pCopyImageInfo->dstImage, kVulkanObjectTypeImage, false, "VUID-VkCopyImageInfo2KHR-dstImage-parameter", "VUID-VkCopyImageInfo2KHR-commonparent");
3839 }
3840
3841 return skip;
3842 }
3843
PreCallValidateCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,const VkCopyBufferToImageInfo2KHR * pCopyBufferToImageInfo) const3844 bool ObjectLifetimes::PreCallValidateCmdCopyBufferToImage2KHR(
3845 VkCommandBuffer commandBuffer,
3846 const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) const {
3847 bool skip = false;
3848 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-parameter", kVUIDUndefined);
3849 if (pCopyBufferToImageInfo) {
3850 skip |= ValidateObject(pCopyBufferToImageInfo->srcBuffer, kVulkanObjectTypeBuffer, false, "VUID-VkCopyBufferToImageInfo2KHR-srcBuffer-parameter", "VUID-VkCopyBufferToImageInfo2KHR-commonparent");
3851 skip |= ValidateObject(pCopyBufferToImageInfo->dstImage, kVulkanObjectTypeImage, false, "VUID-VkCopyBufferToImageInfo2KHR-dstImage-parameter", "VUID-VkCopyBufferToImageInfo2KHR-commonparent");
3852 }
3853
3854 return skip;
3855 }
3856
PreCallValidateCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,const VkCopyImageToBufferInfo2KHR * pCopyImageToBufferInfo) const3857 bool ObjectLifetimes::PreCallValidateCmdCopyImageToBuffer2KHR(
3858 VkCommandBuffer commandBuffer,
3859 const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) const {
3860 bool skip = false;
3861 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-parameter", kVUIDUndefined);
3862 if (pCopyImageToBufferInfo) {
3863 skip |= ValidateObject(pCopyImageToBufferInfo->srcImage, kVulkanObjectTypeImage, false, "VUID-VkCopyImageToBufferInfo2KHR-srcImage-parameter", "VUID-VkCopyImageToBufferInfo2KHR-commonparent");
3864 skip |= ValidateObject(pCopyImageToBufferInfo->dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-VkCopyImageToBufferInfo2KHR-dstBuffer-parameter", "VUID-VkCopyImageToBufferInfo2KHR-commonparent");
3865 }
3866
3867 return skip;
3868 }
3869
PreCallValidateCmdBlitImage2KHR(VkCommandBuffer commandBuffer,const VkBlitImageInfo2KHR * pBlitImageInfo) const3870 bool ObjectLifetimes::PreCallValidateCmdBlitImage2KHR(
3871 VkCommandBuffer commandBuffer,
3872 const VkBlitImageInfo2KHR* pBlitImageInfo) const {
3873 bool skip = false;
3874 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBlitImage2KHR-commandBuffer-parameter", kVUIDUndefined);
3875 if (pBlitImageInfo) {
3876 skip |= ValidateObject(pBlitImageInfo->srcImage, kVulkanObjectTypeImage, false, "VUID-VkBlitImageInfo2KHR-srcImage-parameter", "VUID-VkBlitImageInfo2KHR-commonparent");
3877 skip |= ValidateObject(pBlitImageInfo->dstImage, kVulkanObjectTypeImage, false, "VUID-VkBlitImageInfo2KHR-dstImage-parameter", "VUID-VkBlitImageInfo2KHR-commonparent");
3878 }
3879
3880 return skip;
3881 }
3882
PreCallValidateCmdResolveImage2KHR(VkCommandBuffer commandBuffer,const VkResolveImageInfo2KHR * pResolveImageInfo) const3883 bool ObjectLifetimes::PreCallValidateCmdResolveImage2KHR(
3884 VkCommandBuffer commandBuffer,
3885 const VkResolveImageInfo2KHR* pResolveImageInfo) const {
3886 bool skip = false;
3887 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdResolveImage2KHR-commandBuffer-parameter", kVUIDUndefined);
3888 if (pResolveImageInfo) {
3889 skip |= ValidateObject(pResolveImageInfo->srcImage, kVulkanObjectTypeImage, false, "VUID-VkResolveImageInfo2KHR-srcImage-parameter", "VUID-VkResolveImageInfo2KHR-commonparent");
3890 skip |= ValidateObject(pResolveImageInfo->dstImage, kVulkanObjectTypeImage, false, "VUID-VkResolveImageInfo2KHR-dstImage-parameter", "VUID-VkResolveImageInfo2KHR-commonparent");
3891 }
3892
3893 return skip;
3894 }
3895
PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance,const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugReportCallbackEXT * pCallback) const3896 bool ObjectLifetimes::PreCallValidateCreateDebugReportCallbackEXT(
3897 VkInstance instance,
3898 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
3899 const VkAllocationCallbacks* pAllocator,
3900 VkDebugReportCallbackEXT* pCallback) const {
3901 bool skip = false;
3902 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateDebugReportCallbackEXT-instance-parameter", kVUIDUndefined);
3903
3904 return skip;
3905 }
3906
PostCallRecordCreateDebugReportCallbackEXT(VkInstance instance,const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugReportCallbackEXT * pCallback,VkResult result)3907 void ObjectLifetimes::PostCallRecordCreateDebugReportCallbackEXT(
3908 VkInstance instance,
3909 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
3910 const VkAllocationCallbacks* pAllocator,
3911 VkDebugReportCallbackEXT* pCallback,
3912 VkResult result) {
3913 if (result != VK_SUCCESS) return;
3914 CreateObject(*pCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator);
3915
3916 }
3917
PreCallValidateDestroyDebugReportCallbackEXT(VkInstance instance,VkDebugReportCallbackEXT callback,const VkAllocationCallbacks * pAllocator) const3918 bool ObjectLifetimes::PreCallValidateDestroyDebugReportCallbackEXT(
3919 VkInstance instance,
3920 VkDebugReportCallbackEXT callback,
3921 const VkAllocationCallbacks* pAllocator) const {
3922 bool skip = false;
3923 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkDestroyDebugReportCallbackEXT-instance-parameter", kVUIDUndefined);
3924 skip |= ValidateObject(callback, kVulkanObjectTypeDebugReportCallbackEXT, true, "VUID-vkDestroyDebugReportCallbackEXT-callback-parameter", "VUID-vkDestroyDebugReportCallbackEXT-callback-parent");
3925 skip |= ValidateDestroyObject(callback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator, kVUIDUndefined, kVUIDUndefined);
3926
3927 return skip;
3928 }
3929
PreCallRecordDestroyDebugReportCallbackEXT(VkInstance instance,VkDebugReportCallbackEXT callback,const VkAllocationCallbacks * pAllocator)3930 void ObjectLifetimes::PreCallRecordDestroyDebugReportCallbackEXT(
3931 VkInstance instance,
3932 VkDebugReportCallbackEXT callback,
3933 const VkAllocationCallbacks* pAllocator) {
3934 RecordDestroyObject(callback, kVulkanObjectTypeDebugReportCallbackEXT);
3935
3936 }
3937
PreCallValidateDebugReportMessageEXT(VkInstance instance,VkDebugReportFlagsEXT flags,VkDebugReportObjectTypeEXT objectType,uint64_t object,size_t location,int32_t messageCode,const char * pLayerPrefix,const char * pMessage) const3938 bool ObjectLifetimes::PreCallValidateDebugReportMessageEXT(
3939 VkInstance instance,
3940 VkDebugReportFlagsEXT flags,
3941 VkDebugReportObjectTypeEXT objectType,
3942 uint64_t object,
3943 size_t location,
3944 int32_t messageCode,
3945 const char* pLayerPrefix,
3946 const char* pMessage) const {
3947 bool skip = false;
3948 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkDebugReportMessageEXT-instance-parameter", kVUIDUndefined);
3949
3950 return skip;
3951 }
3952
PreCallValidateDebugMarkerSetObjectTagEXT(VkDevice device,const VkDebugMarkerObjectTagInfoEXT * pTagInfo) const3953 bool ObjectLifetimes::PreCallValidateDebugMarkerSetObjectTagEXT(
3954 VkDevice device,
3955 const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const {
3956 bool skip = false;
3957 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDebugMarkerSetObjectTagEXT-device-parameter", kVUIDUndefined);
3958
3959 return skip;
3960 }
3961
PreCallValidateDebugMarkerSetObjectNameEXT(VkDevice device,const VkDebugMarkerObjectNameInfoEXT * pNameInfo) const3962 bool ObjectLifetimes::PreCallValidateDebugMarkerSetObjectNameEXT(
3963 VkDevice device,
3964 const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const {
3965 bool skip = false;
3966 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDebugMarkerSetObjectNameEXT-device-parameter", kVUIDUndefined);
3967
3968 return skip;
3969 }
3970
PreCallValidateCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,const VkDebugMarkerMarkerInfoEXT * pMarkerInfo) const3971 bool ObjectLifetimes::PreCallValidateCmdDebugMarkerBeginEXT(
3972 VkCommandBuffer commandBuffer,
3973 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const {
3974 bool skip = false;
3975 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter", kVUIDUndefined);
3976
3977 return skip;
3978 }
3979
PreCallValidateCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const3980 bool ObjectLifetimes::PreCallValidateCmdDebugMarkerEndEXT(
3981 VkCommandBuffer commandBuffer) const {
3982 bool skip = false;
3983 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter", kVUIDUndefined);
3984
3985 return skip;
3986 }
3987
PreCallValidateCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,const VkDebugMarkerMarkerInfoEXT * pMarkerInfo) const3988 bool ObjectLifetimes::PreCallValidateCmdDebugMarkerInsertEXT(
3989 VkCommandBuffer commandBuffer,
3990 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const {
3991 bool skip = false;
3992 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter", kVUIDUndefined);
3993
3994 return skip;
3995 }
3996
PreCallValidateCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets,const VkDeviceSize * pSizes) const3997 bool ObjectLifetimes::PreCallValidateCmdBindTransformFeedbackBuffersEXT(
3998 VkCommandBuffer commandBuffer,
3999 uint32_t firstBinding,
4000 uint32_t bindingCount,
4001 const VkBuffer* pBuffers,
4002 const VkDeviceSize* pOffsets,
4003 const VkDeviceSize* pSizes) const {
4004 bool skip = false;
4005 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindTransformFeedbackBuffersEXT-commandBuffer-parameter", "VUID-vkCmdBindTransformFeedbackBuffersEXT-commonparent");
4006 if (pBuffers) {
4007 for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
4008 skip |= ValidateObject(pBuffers[index0], kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-parameter", "VUID-vkCmdBindTransformFeedbackBuffersEXT-commonparent");
4009 }
4010 }
4011
4012 return skip;
4013 }
4014
PreCallValidateCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,uint32_t firstCounterBuffer,uint32_t counterBufferCount,const VkBuffer * pCounterBuffers,const VkDeviceSize * pCounterBufferOffsets) const4015 bool ObjectLifetimes::PreCallValidateCmdBeginTransformFeedbackEXT(
4016 VkCommandBuffer commandBuffer,
4017 uint32_t firstCounterBuffer,
4018 uint32_t counterBufferCount,
4019 const VkBuffer* pCounterBuffers,
4020 const VkDeviceSize* pCounterBufferOffsets) const {
4021 bool skip = false;
4022 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginTransformFeedbackEXT-commandBuffer-parameter", "VUID-vkCmdBeginTransformFeedbackEXT-commonparent");
4023 if (pCounterBuffers) {
4024 for (uint32_t index0 = 0; index0 < counterBufferCount; ++index0) {
4025 skip |= ValidateObject(pCounterBuffers[index0], kVulkanObjectTypeBuffer, true, kVUIDUndefined, "VUID-vkCmdBeginTransformFeedbackEXT-commonparent");
4026 }
4027 }
4028
4029 return skip;
4030 }
4031
PreCallValidateCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,uint32_t firstCounterBuffer,uint32_t counterBufferCount,const VkBuffer * pCounterBuffers,const VkDeviceSize * pCounterBufferOffsets) const4032 bool ObjectLifetimes::PreCallValidateCmdEndTransformFeedbackEXT(
4033 VkCommandBuffer commandBuffer,
4034 uint32_t firstCounterBuffer,
4035 uint32_t counterBufferCount,
4036 const VkBuffer* pCounterBuffers,
4037 const VkDeviceSize* pCounterBufferOffsets) const {
4038 bool skip = false;
4039 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndTransformFeedbackEXT-commandBuffer-parameter", "VUID-vkCmdEndTransformFeedbackEXT-commonparent");
4040 if (pCounterBuffers) {
4041 for (uint32_t index0 = 0; index0 < counterBufferCount; ++index0) {
4042 skip |= ValidateObject(pCounterBuffers[index0], kVulkanObjectTypeBuffer, true, kVUIDUndefined, "VUID-vkCmdEndTransformFeedbackEXT-commonparent");
4043 }
4044 }
4045
4046 return skip;
4047 }
4048
PreCallValidateCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,VkQueryControlFlags flags,uint32_t index) const4049 bool ObjectLifetimes::PreCallValidateCmdBeginQueryIndexedEXT(
4050 VkCommandBuffer commandBuffer,
4051 VkQueryPool queryPool,
4052 uint32_t query,
4053 VkQueryControlFlags flags,
4054 uint32_t index) const {
4055 bool skip = false;
4056 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-parameter", "VUID-vkCmdBeginQueryIndexedEXT-commonparent");
4057 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdBeginQueryIndexedEXT-queryPool-parameter", "VUID-vkCmdBeginQueryIndexedEXT-commonparent");
4058
4059 return skip;
4060 }
4061
PreCallValidateCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,uint32_t index) const4062 bool ObjectLifetimes::PreCallValidateCmdEndQueryIndexedEXT(
4063 VkCommandBuffer commandBuffer,
4064 VkQueryPool queryPool,
4065 uint32_t query,
4066 uint32_t index) const {
4067 bool skip = false;
4068 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndQueryIndexedEXT-commandBuffer-parameter", "VUID-vkCmdEndQueryIndexedEXT-commonparent");
4069 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdEndQueryIndexedEXT-queryPool-parameter", "VUID-vkCmdEndQueryIndexedEXT-commonparent");
4070
4071 return skip;
4072 }
4073
PreCallValidateCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,uint32_t instanceCount,uint32_t firstInstance,VkBuffer counterBuffer,VkDeviceSize counterBufferOffset,uint32_t counterOffset,uint32_t vertexStride) const4074 bool ObjectLifetimes::PreCallValidateCmdDrawIndirectByteCountEXT(
4075 VkCommandBuffer commandBuffer,
4076 uint32_t instanceCount,
4077 uint32_t firstInstance,
4078 VkBuffer counterBuffer,
4079 VkDeviceSize counterBufferOffset,
4080 uint32_t counterOffset,
4081 uint32_t vertexStride) const {
4082 bool skip = false;
4083 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-parameter", "VUID-vkCmdDrawIndirectByteCountEXT-commonparent");
4084 skip |= ValidateObject(counterBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-parameter", "VUID-vkCmdDrawIndirectByteCountEXT-commonparent");
4085
4086 return skip;
4087 }
4088
PreCallValidateGetImageViewHandleNVX(VkDevice device,const VkImageViewHandleInfoNVX * pInfo) const4089 bool ObjectLifetimes::PreCallValidateGetImageViewHandleNVX(
4090 VkDevice device,
4091 const VkImageViewHandleInfoNVX* pInfo) const {
4092 bool skip = false;
4093 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageViewHandleNVX-device-parameter", kVUIDUndefined);
4094
4095 return skip;
4096 }
4097
PreCallValidateGetImageViewAddressNVX(VkDevice device,VkImageView imageView,VkImageViewAddressPropertiesNVX * pProperties) const4098 bool ObjectLifetimes::PreCallValidateGetImageViewAddressNVX(
4099 VkDevice device,
4100 VkImageView imageView,
4101 VkImageViewAddressPropertiesNVX* pProperties) const {
4102 bool skip = false;
4103 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageViewAddressNVX-device-parameter", kVUIDUndefined);
4104 skip |= ValidateObject(imageView, kVulkanObjectTypeImageView, false, "VUID-vkGetImageViewAddressNVX-imageView-parameter", "VUID-vkGetImageViewAddressNVX-imageView-parent");
4105
4106 return skip;
4107 }
4108
PreCallValidateCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const4109 bool ObjectLifetimes::PreCallValidateCmdDrawIndirectCountAMD(
4110 VkCommandBuffer commandBuffer,
4111 VkBuffer buffer,
4112 VkDeviceSize offset,
4113 VkBuffer countBuffer,
4114 VkDeviceSize countBufferOffset,
4115 uint32_t maxDrawCount,
4116 uint32_t stride) const {
4117 bool skip = false;
4118 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirectCount-commandBuffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
4119 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCount-buffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
4120 skip |= ValidateObject(countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCount-countBuffer-parameter", "VUID-vkCmdDrawIndirectCount-commonparent");
4121
4122 return skip;
4123 }
4124
PreCallValidateCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const4125 bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirectCountAMD(
4126 VkCommandBuffer commandBuffer,
4127 VkBuffer buffer,
4128 VkDeviceSize offset,
4129 VkBuffer countBuffer,
4130 VkDeviceSize countBufferOffset,
4131 uint32_t maxDrawCount,
4132 uint32_t stride) const {
4133 bool skip = false;
4134 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
4135 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-buffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
4136 skip |= ValidateObject(countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCount-commonparent");
4137
4138 return skip;
4139 }
4140
PreCallValidateGetShaderInfoAMD(VkDevice device,VkPipeline pipeline,VkShaderStageFlagBits shaderStage,VkShaderInfoTypeAMD infoType,size_t * pInfoSize,void * pInfo) const4141 bool ObjectLifetimes::PreCallValidateGetShaderInfoAMD(
4142 VkDevice device,
4143 VkPipeline pipeline,
4144 VkShaderStageFlagBits shaderStage,
4145 VkShaderInfoTypeAMD infoType,
4146 size_t* pInfoSize,
4147 void* pInfo) const {
4148 bool skip = false;
4149 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetShaderInfoAMD-device-parameter", kVUIDUndefined);
4150 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, false, "VUID-vkGetShaderInfoAMD-pipeline-parameter", "VUID-vkGetShaderInfoAMD-pipeline-parent");
4151
4152 return skip;
4153 }
4154
4155 #ifdef VK_USE_PLATFORM_GGP
4156
PreCallValidateCreateStreamDescriptorSurfaceGGP(VkInstance instance,const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const4157 bool ObjectLifetimes::PreCallValidateCreateStreamDescriptorSurfaceGGP(
4158 VkInstance instance,
4159 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
4160 const VkAllocationCallbacks* pAllocator,
4161 VkSurfaceKHR* pSurface) const {
4162 bool skip = false;
4163 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateStreamDescriptorSurfaceGGP-instance-parameter", kVUIDUndefined);
4164
4165 return skip;
4166 }
4167
PostCallRecordCreateStreamDescriptorSurfaceGGP(VkInstance instance,const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)4168 void ObjectLifetimes::PostCallRecordCreateStreamDescriptorSurfaceGGP(
4169 VkInstance instance,
4170 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
4171 const VkAllocationCallbacks* pAllocator,
4172 VkSurfaceKHR* pSurface,
4173 VkResult result) {
4174 if (result != VK_SUCCESS) return;
4175 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
4176
4177 }
4178 #endif // VK_USE_PLATFORM_GGP
4179
PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkExternalMemoryHandleTypeFlagsNV externalHandleType,VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties) const4180 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(
4181 VkPhysicalDevice physicalDevice,
4182 VkFormat format,
4183 VkImageType type,
4184 VkImageTiling tiling,
4185 VkImageUsageFlags usage,
4186 VkImageCreateFlags flags,
4187 VkExternalMemoryHandleTypeFlagsNV externalHandleType,
4188 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const {
4189 bool skip = false;
4190 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter", kVUIDUndefined);
4191
4192 return skip;
4193 }
4194
4195 #ifdef VK_USE_PLATFORM_WIN32_KHR
4196
PreCallValidateGetMemoryWin32HandleNV(VkDevice device,VkDeviceMemory memory,VkExternalMemoryHandleTypeFlagsNV handleType,HANDLE * pHandle) const4197 bool ObjectLifetimes::PreCallValidateGetMemoryWin32HandleNV(
4198 VkDevice device,
4199 VkDeviceMemory memory,
4200 VkExternalMemoryHandleTypeFlagsNV handleType,
4201 HANDLE* pHandle) const {
4202 bool skip = false;
4203 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryWin32HandleNV-device-parameter", kVUIDUndefined);
4204 skip |= ValidateObject(memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkGetMemoryWin32HandleNV-memory-parameter", "VUID-vkGetMemoryWin32HandleNV-memory-parent");
4205
4206 return skip;
4207 }
4208 #endif // VK_USE_PLATFORM_WIN32_KHR
4209
4210 #ifdef VK_USE_PLATFORM_VI_NN
4211
PreCallValidateCreateViSurfaceNN(VkInstance instance,const VkViSurfaceCreateInfoNN * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const4212 bool ObjectLifetimes::PreCallValidateCreateViSurfaceNN(
4213 VkInstance instance,
4214 const VkViSurfaceCreateInfoNN* pCreateInfo,
4215 const VkAllocationCallbacks* pAllocator,
4216 VkSurfaceKHR* pSurface) const {
4217 bool skip = false;
4218 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateViSurfaceNN-instance-parameter", kVUIDUndefined);
4219
4220 return skip;
4221 }
4222
PostCallRecordCreateViSurfaceNN(VkInstance instance,const VkViSurfaceCreateInfoNN * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)4223 void ObjectLifetimes::PostCallRecordCreateViSurfaceNN(
4224 VkInstance instance,
4225 const VkViSurfaceCreateInfoNN* pCreateInfo,
4226 const VkAllocationCallbacks* pAllocator,
4227 VkSurfaceKHR* pSurface,
4228 VkResult result) {
4229 if (result != VK_SUCCESS) return;
4230 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
4231
4232 }
4233 #endif // VK_USE_PLATFORM_VI_NN
4234
PreCallValidateCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer,const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin) const4235 bool ObjectLifetimes::PreCallValidateCmdBeginConditionalRenderingEXT(
4236 VkCommandBuffer commandBuffer,
4237 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const {
4238 bool skip = false;
4239 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginConditionalRenderingEXT-commandBuffer-parameter", kVUIDUndefined);
4240 if (pConditionalRenderingBegin) {
4241 skip |= ValidateObject(pConditionalRenderingBegin->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkConditionalRenderingBeginInfoEXT-buffer-parameter", kVUIDUndefined);
4242 }
4243
4244 return skip;
4245 }
4246
PreCallValidateCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const4247 bool ObjectLifetimes::PreCallValidateCmdEndConditionalRenderingEXT(
4248 VkCommandBuffer commandBuffer) const {
4249 bool skip = false;
4250 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndConditionalRenderingEXT-commandBuffer-parameter", kVUIDUndefined);
4251
4252 return skip;
4253 }
4254
PreCallValidateCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkViewportWScalingNV * pViewportWScalings) const4255 bool ObjectLifetimes::PreCallValidateCmdSetViewportWScalingNV(
4256 VkCommandBuffer commandBuffer,
4257 uint32_t firstViewport,
4258 uint32_t viewportCount,
4259 const VkViewportWScalingNV* pViewportWScalings) const {
4260 bool skip = false;
4261 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter", kVUIDUndefined);
4262
4263 return skip;
4264 }
4265
PreCallValidateReleaseDisplayEXT(VkPhysicalDevice physicalDevice,VkDisplayKHR display) const4266 bool ObjectLifetimes::PreCallValidateReleaseDisplayEXT(
4267 VkPhysicalDevice physicalDevice,
4268 VkDisplayKHR display) const {
4269 bool skip = false;
4270 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkReleaseDisplayEXT-physicalDevice-parameter", kVUIDUndefined);
4271 skip |= ValidateObject(display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkReleaseDisplayEXT-display-parameter", "VUID-vkReleaseDisplayEXT-display-parent");
4272
4273 return skip;
4274 }
4275
4276 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
4277
PreCallValidateAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice,Display * dpy,VkDisplayKHR display) const4278 bool ObjectLifetimes::PreCallValidateAcquireXlibDisplayEXT(
4279 VkPhysicalDevice physicalDevice,
4280 Display* dpy,
4281 VkDisplayKHR display) const {
4282 bool skip = false;
4283 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter", kVUIDUndefined);
4284 skip |= ValidateObject(display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkAcquireXlibDisplayEXT-display-parameter", "VUID-vkAcquireXlibDisplayEXT-display-parent");
4285
4286 return skip;
4287 }
4288 #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
4289
4290 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
4291
PreCallValidateGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice,Display * dpy,RROutput rrOutput,VkDisplayKHR * pDisplay) const4292 bool ObjectLifetimes::PreCallValidateGetRandROutputDisplayEXT(
4293 VkPhysicalDevice physicalDevice,
4294 Display* dpy,
4295 RROutput rrOutput,
4296 VkDisplayKHR* pDisplay) const {
4297 bool skip = false;
4298 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter", kVUIDUndefined);
4299
4300 return skip;
4301 }
4302
PostCallRecordGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice,Display * dpy,RROutput rrOutput,VkDisplayKHR * pDisplay,VkResult result)4303 void ObjectLifetimes::PostCallRecordGetRandROutputDisplayEXT(
4304 VkPhysicalDevice physicalDevice,
4305 Display* dpy,
4306 RROutput rrOutput,
4307 VkDisplayKHR* pDisplay,
4308 VkResult result) {
4309 if (result != VK_SUCCESS) return;
4310 CreateObject(*pDisplay, kVulkanObjectTypeDisplayKHR, nullptr);
4311
4312 }
4313 #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
4314
PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilities2EXT * pSurfaceCapabilities) const4315 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(
4316 VkPhysicalDevice physicalDevice,
4317 VkSurfaceKHR surface,
4318 VkSurfaceCapabilities2EXT* pSurfaceCapabilities) const {
4319 bool skip = false;
4320 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent");
4321 skip |= ValidateObject(surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent");
4322
4323 return skip;
4324 }
4325
PreCallValidateDisplayPowerControlEXT(VkDevice device,VkDisplayKHR display,const VkDisplayPowerInfoEXT * pDisplayPowerInfo) const4326 bool ObjectLifetimes::PreCallValidateDisplayPowerControlEXT(
4327 VkDevice device,
4328 VkDisplayKHR display,
4329 const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const {
4330 bool skip = false;
4331 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDisplayPowerControlEXT-device-parameter", "VUID-vkDisplayPowerControlEXT-commonparent");
4332 skip |= ValidateObject(display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkDisplayPowerControlEXT-display-parameter", "VUID-vkDisplayPowerControlEXT-commonparent");
4333
4334 return skip;
4335 }
4336
PreCallValidateRegisterDeviceEventEXT(VkDevice device,const VkDeviceEventInfoEXT * pDeviceEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const4337 bool ObjectLifetimes::PreCallValidateRegisterDeviceEventEXT(
4338 VkDevice device,
4339 const VkDeviceEventInfoEXT* pDeviceEventInfo,
4340 const VkAllocationCallbacks* pAllocator,
4341 VkFence* pFence) const {
4342 bool skip = false;
4343 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkRegisterDeviceEventEXT-device-parameter", kVUIDUndefined);
4344
4345 return skip;
4346 }
4347
PostCallRecordRegisterDeviceEventEXT(VkDevice device,const VkDeviceEventInfoEXT * pDeviceEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence,VkResult result)4348 void ObjectLifetimes::PostCallRecordRegisterDeviceEventEXT(
4349 VkDevice device,
4350 const VkDeviceEventInfoEXT* pDeviceEventInfo,
4351 const VkAllocationCallbacks* pAllocator,
4352 VkFence* pFence,
4353 VkResult result) {
4354 if (result != VK_SUCCESS) return;
4355 CreateObject(*pFence, kVulkanObjectTypeFence, pAllocator);
4356
4357 }
4358
PreCallValidateRegisterDisplayEventEXT(VkDevice device,VkDisplayKHR display,const VkDisplayEventInfoEXT * pDisplayEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const4359 bool ObjectLifetimes::PreCallValidateRegisterDisplayEventEXT(
4360 VkDevice device,
4361 VkDisplayKHR display,
4362 const VkDisplayEventInfoEXT* pDisplayEventInfo,
4363 const VkAllocationCallbacks* pAllocator,
4364 VkFence* pFence) const {
4365 bool skip = false;
4366 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkRegisterDisplayEventEXT-device-parameter", "VUID-vkRegisterDisplayEventEXT-commonparent");
4367 skip |= ValidateObject(display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkRegisterDisplayEventEXT-display-parameter", "VUID-vkRegisterDisplayEventEXT-commonparent");
4368
4369 return skip;
4370 }
4371
PostCallRecordRegisterDisplayEventEXT(VkDevice device,VkDisplayKHR display,const VkDisplayEventInfoEXT * pDisplayEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence,VkResult result)4372 void ObjectLifetimes::PostCallRecordRegisterDisplayEventEXT(
4373 VkDevice device,
4374 VkDisplayKHR display,
4375 const VkDisplayEventInfoEXT* pDisplayEventInfo,
4376 const VkAllocationCallbacks* pAllocator,
4377 VkFence* pFence,
4378 VkResult result) {
4379 if (result != VK_SUCCESS) return;
4380 CreateObject(*pFence, kVulkanObjectTypeFence, pAllocator);
4381
4382 }
4383
PreCallValidateGetSwapchainCounterEXT(VkDevice device,VkSwapchainKHR swapchain,VkSurfaceCounterFlagBitsEXT counter,uint64_t * pCounterValue) const4384 bool ObjectLifetimes::PreCallValidateGetSwapchainCounterEXT(
4385 VkDevice device,
4386 VkSwapchainKHR swapchain,
4387 VkSurfaceCounterFlagBitsEXT counter,
4388 uint64_t* pCounterValue) const {
4389 bool skip = false;
4390 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetSwapchainCounterEXT-device-parameter", "VUID-vkGetSwapchainCounterEXT-commonparent");
4391 skip |= ValidateObject(swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetSwapchainCounterEXT-swapchain-parameter", "VUID-vkGetSwapchainCounterEXT-commonparent");
4392
4393 return skip;
4394 }
4395
PreCallValidateGetRefreshCycleDurationGOOGLE(VkDevice device,VkSwapchainKHR swapchain,VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties) const4396 bool ObjectLifetimes::PreCallValidateGetRefreshCycleDurationGOOGLE(
4397 VkDevice device,
4398 VkSwapchainKHR swapchain,
4399 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const {
4400 bool skip = false;
4401 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter", "VUID-vkGetRefreshCycleDurationGOOGLE-commonparent");
4402 skip |= ValidateObject(swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter", "VUID-vkGetRefreshCycleDurationGOOGLE-commonparent");
4403
4404 return skip;
4405 }
4406
PreCallValidateGetPastPresentationTimingGOOGLE(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pPresentationTimingCount,VkPastPresentationTimingGOOGLE * pPresentationTimings) const4407 bool ObjectLifetimes::PreCallValidateGetPastPresentationTimingGOOGLE(
4408 VkDevice device,
4409 VkSwapchainKHR swapchain,
4410 uint32_t* pPresentationTimingCount,
4411 VkPastPresentationTimingGOOGLE* pPresentationTimings) const {
4412 bool skip = false;
4413 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetPastPresentationTimingGOOGLE-device-parameter", "VUID-vkGetPastPresentationTimingGOOGLE-commonparent");
4414 skip |= ValidateObject(swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter", "VUID-vkGetPastPresentationTimingGOOGLE-commonparent");
4415
4416 return skip;
4417 }
4418
PreCallValidateCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,uint32_t firstDiscardRectangle,uint32_t discardRectangleCount,const VkRect2D * pDiscardRectangles) const4419 bool ObjectLifetimes::PreCallValidateCmdSetDiscardRectangleEXT(
4420 VkCommandBuffer commandBuffer,
4421 uint32_t firstDiscardRectangle,
4422 uint32_t discardRectangleCount,
4423 const VkRect2D* pDiscardRectangles) const {
4424 bool skip = false;
4425 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter", kVUIDUndefined);
4426
4427 return skip;
4428 }
4429
PreCallValidateSetHdrMetadataEXT(VkDevice device,uint32_t swapchainCount,const VkSwapchainKHR * pSwapchains,const VkHdrMetadataEXT * pMetadata) const4430 bool ObjectLifetimes::PreCallValidateSetHdrMetadataEXT(
4431 VkDevice device,
4432 uint32_t swapchainCount,
4433 const VkSwapchainKHR* pSwapchains,
4434 const VkHdrMetadataEXT* pMetadata) const {
4435 bool skip = false;
4436 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkSetHdrMetadataEXT-device-parameter", "VUID-vkSetHdrMetadataEXT-commonparent");
4437 if (pSwapchains) {
4438 for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) {
4439 skip |= ValidateObject(pSwapchains[index0], kVulkanObjectTypeSwapchainKHR, false, "VUID-vkSetHdrMetadataEXT-pSwapchains-parameter", "VUID-vkSetHdrMetadataEXT-commonparent");
4440 }
4441 }
4442
4443 return skip;
4444 }
4445
4446 #ifdef VK_USE_PLATFORM_IOS_MVK
4447
PreCallValidateCreateIOSSurfaceMVK(VkInstance instance,const VkIOSSurfaceCreateInfoMVK * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const4448 bool ObjectLifetimes::PreCallValidateCreateIOSSurfaceMVK(
4449 VkInstance instance,
4450 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
4451 const VkAllocationCallbacks* pAllocator,
4452 VkSurfaceKHR* pSurface) const {
4453 bool skip = false;
4454 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateIOSSurfaceMVK-instance-parameter", kVUIDUndefined);
4455
4456 return skip;
4457 }
4458
PostCallRecordCreateIOSSurfaceMVK(VkInstance instance,const VkIOSSurfaceCreateInfoMVK * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)4459 void ObjectLifetimes::PostCallRecordCreateIOSSurfaceMVK(
4460 VkInstance instance,
4461 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
4462 const VkAllocationCallbacks* pAllocator,
4463 VkSurfaceKHR* pSurface,
4464 VkResult result) {
4465 if (result != VK_SUCCESS) return;
4466 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
4467
4468 }
4469 #endif // VK_USE_PLATFORM_IOS_MVK
4470
4471 #ifdef VK_USE_PLATFORM_MACOS_MVK
4472
PreCallValidateCreateMacOSSurfaceMVK(VkInstance instance,const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const4473 bool ObjectLifetimes::PreCallValidateCreateMacOSSurfaceMVK(
4474 VkInstance instance,
4475 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
4476 const VkAllocationCallbacks* pAllocator,
4477 VkSurfaceKHR* pSurface) const {
4478 bool skip = false;
4479 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateMacOSSurfaceMVK-instance-parameter", kVUIDUndefined);
4480
4481 return skip;
4482 }
4483
PostCallRecordCreateMacOSSurfaceMVK(VkInstance instance,const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)4484 void ObjectLifetimes::PostCallRecordCreateMacOSSurfaceMVK(
4485 VkInstance instance,
4486 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
4487 const VkAllocationCallbacks* pAllocator,
4488 VkSurfaceKHR* pSurface,
4489 VkResult result) {
4490 if (result != VK_SUCCESS) return;
4491 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
4492
4493 }
4494 #endif // VK_USE_PLATFORM_MACOS_MVK
4495
PreCallValidateQueueBeginDebugUtilsLabelEXT(VkQueue queue,const VkDebugUtilsLabelEXT * pLabelInfo) const4496 bool ObjectLifetimes::PreCallValidateQueueBeginDebugUtilsLabelEXT(
4497 VkQueue queue,
4498 const VkDebugUtilsLabelEXT* pLabelInfo) const {
4499 bool skip = false;
4500 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter", kVUIDUndefined);
4501
4502 return skip;
4503 }
4504
PreCallValidateQueueEndDebugUtilsLabelEXT(VkQueue queue) const4505 bool ObjectLifetimes::PreCallValidateQueueEndDebugUtilsLabelEXT(
4506 VkQueue queue) const {
4507 bool skip = false;
4508 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter", kVUIDUndefined);
4509
4510 return skip;
4511 }
4512
PreCallValidateQueueInsertDebugUtilsLabelEXT(VkQueue queue,const VkDebugUtilsLabelEXT * pLabelInfo) const4513 bool ObjectLifetimes::PreCallValidateQueueInsertDebugUtilsLabelEXT(
4514 VkQueue queue,
4515 const VkDebugUtilsLabelEXT* pLabelInfo) const {
4516 bool skip = false;
4517 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter", kVUIDUndefined);
4518
4519 return skip;
4520 }
4521
PreCallValidateCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,const VkDebugUtilsLabelEXT * pLabelInfo) const4522 bool ObjectLifetimes::PreCallValidateCmdBeginDebugUtilsLabelEXT(
4523 VkCommandBuffer commandBuffer,
4524 const VkDebugUtilsLabelEXT* pLabelInfo) const {
4525 bool skip = false;
4526 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
4527
4528 return skip;
4529 }
4530
PreCallValidateCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const4531 bool ObjectLifetimes::PreCallValidateCmdEndDebugUtilsLabelEXT(
4532 VkCommandBuffer commandBuffer) const {
4533 bool skip = false;
4534 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
4535
4536 return skip;
4537 }
4538
PreCallValidateCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,const VkDebugUtilsLabelEXT * pLabelInfo) const4539 bool ObjectLifetimes::PreCallValidateCmdInsertDebugUtilsLabelEXT(
4540 VkCommandBuffer commandBuffer,
4541 const VkDebugUtilsLabelEXT* pLabelInfo) const {
4542 bool skip = false;
4543 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
4544
4545 return skip;
4546 }
4547
PreCallValidateCreateDebugUtilsMessengerEXT(VkInstance instance,const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugUtilsMessengerEXT * pMessenger) const4548 bool ObjectLifetimes::PreCallValidateCreateDebugUtilsMessengerEXT(
4549 VkInstance instance,
4550 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
4551 const VkAllocationCallbacks* pAllocator,
4552 VkDebugUtilsMessengerEXT* pMessenger) const {
4553 bool skip = false;
4554 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
4555
4556 return skip;
4557 }
4558
PostCallRecordCreateDebugUtilsMessengerEXT(VkInstance instance,const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugUtilsMessengerEXT * pMessenger,VkResult result)4559 void ObjectLifetimes::PostCallRecordCreateDebugUtilsMessengerEXT(
4560 VkInstance instance,
4561 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
4562 const VkAllocationCallbacks* pAllocator,
4563 VkDebugUtilsMessengerEXT* pMessenger,
4564 VkResult result) {
4565 if (result != VK_SUCCESS) return;
4566 CreateObject(*pMessenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator);
4567
4568 }
4569
PreCallValidateDestroyDebugUtilsMessengerEXT(VkInstance instance,VkDebugUtilsMessengerEXT messenger,const VkAllocationCallbacks * pAllocator) const4570 bool ObjectLifetimes::PreCallValidateDestroyDebugUtilsMessengerEXT(
4571 VkInstance instance,
4572 VkDebugUtilsMessengerEXT messenger,
4573 const VkAllocationCallbacks* pAllocator) const {
4574 bool skip = false;
4575 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
4576 skip |= ValidateObject(messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, true, "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter", "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent");
4577 skip |= ValidateDestroyObject(messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator, kVUIDUndefined, kVUIDUndefined);
4578
4579 return skip;
4580 }
4581
PreCallRecordDestroyDebugUtilsMessengerEXT(VkInstance instance,VkDebugUtilsMessengerEXT messenger,const VkAllocationCallbacks * pAllocator)4582 void ObjectLifetimes::PreCallRecordDestroyDebugUtilsMessengerEXT(
4583 VkInstance instance,
4584 VkDebugUtilsMessengerEXT messenger,
4585 const VkAllocationCallbacks* pAllocator) {
4586 RecordDestroyObject(messenger, kVulkanObjectTypeDebugUtilsMessengerEXT);
4587
4588 }
4589
PreCallValidateSubmitDebugUtilsMessageEXT(VkInstance instance,VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VkDebugUtilsMessageTypeFlagsEXT messageTypes,const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData) const4590 bool ObjectLifetimes::PreCallValidateSubmitDebugUtilsMessageEXT(
4591 VkInstance instance,
4592 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
4593 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
4594 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) const {
4595 bool skip = false;
4596 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter", kVUIDUndefined);
4597
4598 return skip;
4599 }
4600
4601 #ifdef VK_USE_PLATFORM_ANDROID_KHR
4602
PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(VkDevice device,const struct AHardwareBuffer * buffer,VkAndroidHardwareBufferPropertiesANDROID * pProperties) const4603 bool ObjectLifetimes::PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(
4604 VkDevice device,
4605 const struct AHardwareBuffer* buffer,
4606 VkAndroidHardwareBufferPropertiesANDROID* pProperties) const {
4607 bool skip = false;
4608 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter", kVUIDUndefined);
4609
4610 return skip;
4611 }
4612 #endif // VK_USE_PLATFORM_ANDROID_KHR
4613
4614 #ifdef VK_USE_PLATFORM_ANDROID_KHR
4615
PreCallValidateGetMemoryAndroidHardwareBufferANDROID(VkDevice device,const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,struct AHardwareBuffer ** pBuffer) const4616 bool ObjectLifetimes::PreCallValidateGetMemoryAndroidHardwareBufferANDROID(
4617 VkDevice device,
4618 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
4619 struct AHardwareBuffer** pBuffer) const {
4620 bool skip = false;
4621 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter", kVUIDUndefined);
4622 if (pInfo) {
4623 skip |= ValidateObject(pInfo->memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-memory-parameter", kVUIDUndefined);
4624 }
4625
4626 return skip;
4627 }
4628 #endif // VK_USE_PLATFORM_ANDROID_KHR
4629
PreCallValidateCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,const VkSampleLocationsInfoEXT * pSampleLocationsInfo) const4630 bool ObjectLifetimes::PreCallValidateCmdSetSampleLocationsEXT(
4631 VkCommandBuffer commandBuffer,
4632 const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const {
4633 bool skip = false;
4634 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter", kVUIDUndefined);
4635
4636 return skip;
4637 }
4638
PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,VkSampleCountFlagBits samples,VkMultisamplePropertiesEXT * pMultisampleProperties) const4639 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(
4640 VkPhysicalDevice physicalDevice,
4641 VkSampleCountFlagBits samples,
4642 VkMultisamplePropertiesEXT* pMultisampleProperties) const {
4643 bool skip = false;
4644 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter", kVUIDUndefined);
4645
4646 return skip;
4647 }
4648
PreCallValidateGetImageDrmFormatModifierPropertiesEXT(VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties) const4649 bool ObjectLifetimes::PreCallValidateGetImageDrmFormatModifierPropertiesEXT(
4650 VkDevice device,
4651 VkImage image,
4652 VkImageDrmFormatModifierPropertiesEXT* pProperties) const {
4653 bool skip = false;
4654 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageDrmFormatModifierPropertiesEXT-device-parameter", kVUIDUndefined);
4655 skip |= ValidateObject(image, kVulkanObjectTypeImage, false, "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parameter", "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parent");
4656
4657 return skip;
4658 }
4659
PreCallValidateCreateValidationCacheEXT(VkDevice device,const VkValidationCacheCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkValidationCacheEXT * pValidationCache) const4660 bool ObjectLifetimes::PreCallValidateCreateValidationCacheEXT(
4661 VkDevice device,
4662 const VkValidationCacheCreateInfoEXT* pCreateInfo,
4663 const VkAllocationCallbacks* pAllocator,
4664 VkValidationCacheEXT* pValidationCache) const {
4665 bool skip = false;
4666 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateValidationCacheEXT-device-parameter", kVUIDUndefined);
4667
4668 return skip;
4669 }
4670
PostCallRecordCreateValidationCacheEXT(VkDevice device,const VkValidationCacheCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkValidationCacheEXT * pValidationCache,VkResult result)4671 void ObjectLifetimes::PostCallRecordCreateValidationCacheEXT(
4672 VkDevice device,
4673 const VkValidationCacheCreateInfoEXT* pCreateInfo,
4674 const VkAllocationCallbacks* pAllocator,
4675 VkValidationCacheEXT* pValidationCache,
4676 VkResult result) {
4677 if (result != VK_SUCCESS) return;
4678 CreateObject(*pValidationCache, kVulkanObjectTypeValidationCacheEXT, pAllocator);
4679
4680 }
4681
PreCallValidateDestroyValidationCacheEXT(VkDevice device,VkValidationCacheEXT validationCache,const VkAllocationCallbacks * pAllocator) const4682 bool ObjectLifetimes::PreCallValidateDestroyValidationCacheEXT(
4683 VkDevice device,
4684 VkValidationCacheEXT validationCache,
4685 const VkAllocationCallbacks* pAllocator) const {
4686 bool skip = false;
4687 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyValidationCacheEXT-device-parameter", kVUIDUndefined);
4688 skip |= ValidateObject(validationCache, kVulkanObjectTypeValidationCacheEXT, true, "VUID-vkDestroyValidationCacheEXT-validationCache-parameter", "VUID-vkDestroyValidationCacheEXT-validationCache-parent");
4689 skip |= ValidateDestroyObject(validationCache, kVulkanObjectTypeValidationCacheEXT, pAllocator, kVUIDUndefined, kVUIDUndefined);
4690
4691 return skip;
4692 }
4693
PreCallRecordDestroyValidationCacheEXT(VkDevice device,VkValidationCacheEXT validationCache,const VkAllocationCallbacks * pAllocator)4694 void ObjectLifetimes::PreCallRecordDestroyValidationCacheEXT(
4695 VkDevice device,
4696 VkValidationCacheEXT validationCache,
4697 const VkAllocationCallbacks* pAllocator) {
4698 RecordDestroyObject(validationCache, kVulkanObjectTypeValidationCacheEXT);
4699
4700 }
4701
PreCallValidateMergeValidationCachesEXT(VkDevice device,VkValidationCacheEXT dstCache,uint32_t srcCacheCount,const VkValidationCacheEXT * pSrcCaches) const4702 bool ObjectLifetimes::PreCallValidateMergeValidationCachesEXT(
4703 VkDevice device,
4704 VkValidationCacheEXT dstCache,
4705 uint32_t srcCacheCount,
4706 const VkValidationCacheEXT* pSrcCaches) const {
4707 bool skip = false;
4708 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkMergeValidationCachesEXT-device-parameter", kVUIDUndefined);
4709 skip |= ValidateObject(dstCache, kVulkanObjectTypeValidationCacheEXT, false, "VUID-vkMergeValidationCachesEXT-dstCache-parameter", "VUID-vkMergeValidationCachesEXT-dstCache-parent");
4710 if (pSrcCaches) {
4711 for (uint32_t index0 = 0; index0 < srcCacheCount; ++index0) {
4712 skip |= ValidateObject(pSrcCaches[index0], kVulkanObjectTypeValidationCacheEXT, false, "VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter", "VUID-vkMergeValidationCachesEXT-pSrcCaches-parent");
4713 }
4714 }
4715
4716 return skip;
4717 }
4718
PreCallValidateGetValidationCacheDataEXT(VkDevice device,VkValidationCacheEXT validationCache,size_t * pDataSize,void * pData) const4719 bool ObjectLifetimes::PreCallValidateGetValidationCacheDataEXT(
4720 VkDevice device,
4721 VkValidationCacheEXT validationCache,
4722 size_t* pDataSize,
4723 void* pData) const {
4724 bool skip = false;
4725 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetValidationCacheDataEXT-device-parameter", kVUIDUndefined);
4726 skip |= ValidateObject(validationCache, kVulkanObjectTypeValidationCacheEXT, false, "VUID-vkGetValidationCacheDataEXT-validationCache-parameter", "VUID-vkGetValidationCacheDataEXT-validationCache-parent");
4727
4728 return skip;
4729 }
4730
PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer,VkImageView imageView,VkImageLayout imageLayout) const4731 bool ObjectLifetimes::PreCallValidateCmdBindShadingRateImageNV(
4732 VkCommandBuffer commandBuffer,
4733 VkImageView imageView,
4734 VkImageLayout imageLayout) const {
4735 bool skip = false;
4736 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindShadingRateImageNV-commandBuffer-parameter", "VUID-vkCmdBindShadingRateImageNV-commonparent");
4737 skip |= ValidateObject(imageView, kVulkanObjectTypeImageView, true, "VUID-vkCmdBindShadingRateImageNV-imageView-parameter", "VUID-vkCmdBindShadingRateImageNV-commonparent");
4738
4739 return skip;
4740 }
4741
PreCallValidateCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkShadingRatePaletteNV * pShadingRatePalettes) const4742 bool ObjectLifetimes::PreCallValidateCmdSetViewportShadingRatePaletteNV(
4743 VkCommandBuffer commandBuffer,
4744 uint32_t firstViewport,
4745 uint32_t viewportCount,
4746 const VkShadingRatePaletteNV* pShadingRatePalettes) const {
4747 bool skip = false;
4748 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-parameter", kVUIDUndefined);
4749
4750 return skip;
4751 }
4752
PreCallValidateCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,VkCoarseSampleOrderTypeNV sampleOrderType,uint32_t customSampleOrderCount,const VkCoarseSampleOrderCustomNV * pCustomSampleOrders) const4753 bool ObjectLifetimes::PreCallValidateCmdSetCoarseSampleOrderNV(
4754 VkCommandBuffer commandBuffer,
4755 VkCoarseSampleOrderTypeNV sampleOrderType,
4756 uint32_t customSampleOrderCount,
4757 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) const {
4758 bool skip = false;
4759 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-parameter", kVUIDUndefined);
4760
4761 return skip;
4762 }
4763
PreCallValidateCreateAccelerationStructureNV(VkDevice device,const VkAccelerationStructureCreateInfoNV * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkAccelerationStructureNV * pAccelerationStructure) const4764 bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureNV(
4765 VkDevice device,
4766 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
4767 const VkAllocationCallbacks* pAllocator,
4768 VkAccelerationStructureNV* pAccelerationStructure) const {
4769 bool skip = false;
4770 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateAccelerationStructureNV-device-parameter", kVUIDUndefined);
4771 if (pCreateInfo) {
4772 if (pCreateInfo->info.pGeometries) {
4773 for (uint32_t index2 = 0; index2 < pCreateInfo->info.geometryCount; ++index2) {
4774 skip |= ValidateObject(pCreateInfo->info.pGeometries[index2].geometry.triangles.vertexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-vertexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
4775 skip |= ValidateObject(pCreateInfo->info.pGeometries[index2].geometry.triangles.indexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-indexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
4776 skip |= ValidateObject(pCreateInfo->info.pGeometries[index2].geometry.triangles.transformData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-transformData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
4777 skip |= ValidateObject(pCreateInfo->info.pGeometries[index2].geometry.aabbs.aabbData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryAABBNV-aabbData-parameter", kVUIDUndefined);
4778 }
4779 }
4780 }
4781
4782 return skip;
4783 }
4784
PostCallRecordCreateAccelerationStructureNV(VkDevice device,const VkAccelerationStructureCreateInfoNV * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkAccelerationStructureNV * pAccelerationStructure,VkResult result)4785 void ObjectLifetimes::PostCallRecordCreateAccelerationStructureNV(
4786 VkDevice device,
4787 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
4788 const VkAllocationCallbacks* pAllocator,
4789 VkAccelerationStructureNV* pAccelerationStructure,
4790 VkResult result) {
4791 if (result != VK_SUCCESS) return;
4792 CreateObject(*pAccelerationStructure, kVulkanObjectTypeAccelerationStructureNV, pAllocator);
4793
4794 }
4795
PreCallValidateDestroyAccelerationStructureKHR(VkDevice device,VkAccelerationStructureKHR accelerationStructure,const VkAllocationCallbacks * pAllocator) const4796 bool ObjectLifetimes::PreCallValidateDestroyAccelerationStructureKHR(
4797 VkDevice device,
4798 VkAccelerationStructureKHR accelerationStructure,
4799 const VkAllocationCallbacks* pAllocator) const {
4800 bool skip = false;
4801 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyAccelerationStructureKHR-device-parameter", kVUIDUndefined);
4802 skip |= ValidateObject(accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, true, "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-parameter", "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-parent");
4803 skip |= ValidateDestroyObject(accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, pAllocator, kVUIDUndefined, kVUIDUndefined);
4804
4805 return skip;
4806 }
4807
PreCallRecordDestroyAccelerationStructureKHR(VkDevice device,VkAccelerationStructureKHR accelerationStructure,const VkAllocationCallbacks * pAllocator)4808 void ObjectLifetimes::PreCallRecordDestroyAccelerationStructureKHR(
4809 VkDevice device,
4810 VkAccelerationStructureKHR accelerationStructure,
4811 const VkAllocationCallbacks* pAllocator) {
4812 RecordDestroyObject(accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR);
4813
4814 }
4815
PreCallValidateDestroyAccelerationStructureNV(VkDevice device,VkAccelerationStructureKHR accelerationStructure,const VkAllocationCallbacks * pAllocator) const4816 bool ObjectLifetimes::PreCallValidateDestroyAccelerationStructureNV(
4817 VkDevice device,
4818 VkAccelerationStructureKHR accelerationStructure,
4819 const VkAllocationCallbacks* pAllocator) const {
4820 bool skip = false;
4821 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyAccelerationStructureKHR-device-parameter", kVUIDUndefined);
4822 skip |= ValidateObject(accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, true, "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-parameter", "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-parent");
4823 skip |= ValidateDestroyObject(accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, pAllocator, kVUIDUndefined, kVUIDUndefined);
4824
4825 return skip;
4826 }
4827
PreCallRecordDestroyAccelerationStructureNV(VkDevice device,VkAccelerationStructureKHR accelerationStructure,const VkAllocationCallbacks * pAllocator)4828 void ObjectLifetimes::PreCallRecordDestroyAccelerationStructureNV(
4829 VkDevice device,
4830 VkAccelerationStructureKHR accelerationStructure,
4831 const VkAllocationCallbacks* pAllocator) {
4832 RecordDestroyObject(accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR);
4833
4834 }
4835
PreCallValidateGetAccelerationStructureMemoryRequirementsNV(VkDevice device,const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,VkMemoryRequirements2KHR * pMemoryRequirements) const4836 bool ObjectLifetimes::PreCallValidateGetAccelerationStructureMemoryRequirementsNV(
4837 VkDevice device,
4838 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
4839 VkMemoryRequirements2KHR* pMemoryRequirements) const {
4840 bool skip = false;
4841 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetAccelerationStructureMemoryRequirementsNV-device-parameter", kVUIDUndefined);
4842 if (pInfo) {
4843 skip |= ValidateObject(pInfo->accelerationStructure, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-VkAccelerationStructureMemoryRequirementsInfoNV-accelerationStructure-parameter", kVUIDUndefined);
4844 }
4845
4846 return skip;
4847 }
4848
PreCallValidateBindAccelerationStructureMemoryKHR(VkDevice device,uint32_t bindInfoCount,const VkBindAccelerationStructureMemoryInfoKHR * pBindInfos) const4849 bool ObjectLifetimes::PreCallValidateBindAccelerationStructureMemoryKHR(
4850 VkDevice device,
4851 uint32_t bindInfoCount,
4852 const VkBindAccelerationStructureMemoryInfoKHR* pBindInfos) const {
4853 bool skip = false;
4854 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindAccelerationStructureMemoryKHR-device-parameter", kVUIDUndefined);
4855 if (pBindInfos) {
4856 for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
4857 skip |= ValidateObject(pBindInfos[index0].accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkBindAccelerationStructureMemoryInfoKHR-accelerationStructure-parameter", "VUID-VkBindAccelerationStructureMemoryInfoKHR-commonparent");
4858 skip |= ValidateObject(pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkBindAccelerationStructureMemoryInfoKHR-memory-parameter", "VUID-VkBindAccelerationStructureMemoryInfoKHR-commonparent");
4859 }
4860 }
4861
4862 return skip;
4863 }
4864
PreCallValidateBindAccelerationStructureMemoryNV(VkDevice device,uint32_t bindInfoCount,const VkBindAccelerationStructureMemoryInfoKHR * pBindInfos) const4865 bool ObjectLifetimes::PreCallValidateBindAccelerationStructureMemoryNV(
4866 VkDevice device,
4867 uint32_t bindInfoCount,
4868 const VkBindAccelerationStructureMemoryInfoKHR* pBindInfos) const {
4869 bool skip = false;
4870 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBindAccelerationStructureMemoryKHR-device-parameter", kVUIDUndefined);
4871 if (pBindInfos) {
4872 for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
4873 skip |= ValidateObject(pBindInfos[index0].accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkBindAccelerationStructureMemoryInfoKHR-accelerationStructure-parameter", "VUID-VkBindAccelerationStructureMemoryInfoKHR-commonparent");
4874 skip |= ValidateObject(pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkBindAccelerationStructureMemoryInfoKHR-memory-parameter", "VUID-VkBindAccelerationStructureMemoryInfoKHR-commonparent");
4875 }
4876 }
4877
4878 return skip;
4879 }
4880
PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,const VkAccelerationStructureInfoNV * pInfo,VkBuffer instanceData,VkDeviceSize instanceOffset,VkBool32 update,VkAccelerationStructureKHR dst,VkAccelerationStructureKHR src,VkBuffer scratch,VkDeviceSize scratchOffset) const4881 bool ObjectLifetimes::PreCallValidateCmdBuildAccelerationStructureNV(
4882 VkCommandBuffer commandBuffer,
4883 const VkAccelerationStructureInfoNV* pInfo,
4884 VkBuffer instanceData,
4885 VkDeviceSize instanceOffset,
4886 VkBool32 update,
4887 VkAccelerationStructureKHR dst,
4888 VkAccelerationStructureKHR src,
4889 VkBuffer scratch,
4890 VkDeviceSize scratchOffset) const {
4891 bool skip = false;
4892 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
4893 if (pInfo) {
4894 if (pInfo->pGeometries) {
4895 for (uint32_t index1 = 0; index1 < pInfo->geometryCount; ++index1) {
4896 skip |= ValidateObject(pInfo->pGeometries[index1].geometry.triangles.vertexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-vertexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
4897 skip |= ValidateObject(pInfo->pGeometries[index1].geometry.triangles.indexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-indexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
4898 skip |= ValidateObject(pInfo->pGeometries[index1].geometry.triangles.transformData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-transformData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
4899 skip |= ValidateObject(pInfo->pGeometries[index1].geometry.aabbs.aabbData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryAABBNV-aabbData-parameter", kVUIDUndefined);
4900 }
4901 }
4902 }
4903 skip |= ValidateObject(instanceData, kVulkanObjectTypeBuffer, true, "VUID-vkCmdBuildAccelerationStructureNV-instanceData-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
4904 skip |= ValidateObject(dst, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-vkCmdBuildAccelerationStructureNV-dst-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
4905 skip |= ValidateObject(src, kVulkanObjectTypeAccelerationStructureKHR, true, "VUID-vkCmdBuildAccelerationStructureNV-src-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
4906 skip |= ValidateObject(scratch, kVulkanObjectTypeBuffer, false, "VUID-vkCmdBuildAccelerationStructureNV-scratch-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
4907
4908 return skip;
4909 }
4910
PreCallValidateCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,VkAccelerationStructureKHR dst,VkAccelerationStructureKHR src,VkCopyAccelerationStructureModeKHR mode) const4911 bool ObjectLifetimes::PreCallValidateCmdCopyAccelerationStructureNV(
4912 VkCommandBuffer commandBuffer,
4913 VkAccelerationStructureKHR dst,
4914 VkAccelerationStructureKHR src,
4915 VkCopyAccelerationStructureModeKHR mode) const {
4916 bool skip = false;
4917 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-parameter", "VUID-vkCmdCopyAccelerationStructureNV-commonparent");
4918 skip |= ValidateObject(dst, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-vkCmdCopyAccelerationStructureNV-dst-parameter", "VUID-vkCmdCopyAccelerationStructureNV-commonparent");
4919 skip |= ValidateObject(src, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-vkCmdCopyAccelerationStructureNV-src-parameter", "VUID-vkCmdCopyAccelerationStructureNV-commonparent");
4920
4921 return skip;
4922 }
4923
PreCallValidateCmdTraceRaysNV(VkCommandBuffer commandBuffer,VkBuffer raygenShaderBindingTableBuffer,VkDeviceSize raygenShaderBindingOffset,VkBuffer missShaderBindingTableBuffer,VkDeviceSize missShaderBindingOffset,VkDeviceSize missShaderBindingStride,VkBuffer hitShaderBindingTableBuffer,VkDeviceSize hitShaderBindingOffset,VkDeviceSize hitShaderBindingStride,VkBuffer callableShaderBindingTableBuffer,VkDeviceSize callableShaderBindingOffset,VkDeviceSize callableShaderBindingStride,uint32_t width,uint32_t height,uint32_t depth) const4924 bool ObjectLifetimes::PreCallValidateCmdTraceRaysNV(
4925 VkCommandBuffer commandBuffer,
4926 VkBuffer raygenShaderBindingTableBuffer,
4927 VkDeviceSize raygenShaderBindingOffset,
4928 VkBuffer missShaderBindingTableBuffer,
4929 VkDeviceSize missShaderBindingOffset,
4930 VkDeviceSize missShaderBindingStride,
4931 VkBuffer hitShaderBindingTableBuffer,
4932 VkDeviceSize hitShaderBindingOffset,
4933 VkDeviceSize hitShaderBindingStride,
4934 VkBuffer callableShaderBindingTableBuffer,
4935 VkDeviceSize callableShaderBindingOffset,
4936 VkDeviceSize callableShaderBindingStride,
4937 uint32_t width,
4938 uint32_t height,
4939 uint32_t depth) const {
4940 bool skip = false;
4941 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdTraceRaysNV-commandBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
4942 skip |= ValidateObject(raygenShaderBindingTableBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
4943 skip |= ValidateObject(missShaderBindingTableBuffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdTraceRaysNV-missShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
4944 skip |= ValidateObject(hitShaderBindingTableBuffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdTraceRaysNV-hitShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
4945 skip |= ValidateObject(callableShaderBindingTableBuffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdTraceRaysNV-callableShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
4946
4947 return skip;
4948 }
4949
PreCallValidateCreateRayTracingPipelinesNV(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkRayTracingPipelineCreateInfoNV * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const4950 bool ObjectLifetimes::PreCallValidateCreateRayTracingPipelinesNV(
4951 VkDevice device,
4952 VkPipelineCache pipelineCache,
4953 uint32_t createInfoCount,
4954 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
4955 const VkAllocationCallbacks* pAllocator,
4956 VkPipeline* pPipelines) const {
4957 bool skip = false;
4958 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRayTracingPipelinesNV-device-parameter", kVUIDUndefined);
4959 skip |= ValidateObject(pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parameter", "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parent");
4960 if (pCreateInfos) {
4961 for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
4962 if (pCreateInfos[index0].pStages) {
4963 for (uint32_t index1 = 0; index1 < pCreateInfos[index0].stageCount; ++index1) {
4964 skip |= ValidateObject(pCreateInfos[index0].pStages[index1].module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
4965 }
4966 }
4967 skip |= ValidateObject(pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkRayTracingPipelineCreateInfoNV-layout-parameter", "VUID-VkRayTracingPipelineCreateInfoNV-commonparent");
4968 if ((pCreateInfos[index0].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) && (pCreateInfos[index0].basePipelineIndex == -1))
4969 skip |= ValidateObject(pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, false, "VUID-VkRayTracingPipelineCreateInfoNV-flags-03421", "VUID-VkRayTracingPipelineCreateInfoNV-commonparent");
4970 }
4971 }
4972
4973 return skip;
4974 }
4975
PostCallRecordCreateRayTracingPipelinesNV(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkRayTracingPipelineCreateInfoNV * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,VkResult result)4976 void ObjectLifetimes::PostCallRecordCreateRayTracingPipelinesNV(
4977 VkDevice device,
4978 VkPipelineCache pipelineCache,
4979 uint32_t createInfoCount,
4980 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
4981 const VkAllocationCallbacks* pAllocator,
4982 VkPipeline* pPipelines,
4983 VkResult result) {
4984 if (VK_ERROR_VALIDATION_FAILED_EXT == result) return;
4985 if (pPipelines) {
4986 for (uint32_t index = 0; index < createInfoCount; index++) {
4987 if (!pPipelines[index]) continue;
4988 CreateObject(pPipelines[index], kVulkanObjectTypePipeline, pAllocator);
4989 }
4990 }
4991
4992 }
4993
PreCallValidateGetRayTracingShaderGroupHandlesKHR(VkDevice device,VkPipeline pipeline,uint32_t firstGroup,uint32_t groupCount,size_t dataSize,void * pData) const4994 bool ObjectLifetimes::PreCallValidateGetRayTracingShaderGroupHandlesKHR(
4995 VkDevice device,
4996 VkPipeline pipeline,
4997 uint32_t firstGroup,
4998 uint32_t groupCount,
4999 size_t dataSize,
5000 void* pData) const {
5001 bool skip = false;
5002 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetRayTracingShaderGroupHandlesKHR-device-parameter", kVUIDUndefined);
5003 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, false, "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-parameter", "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-parent");
5004
5005 return skip;
5006 }
5007
PreCallValidateGetRayTracingShaderGroupHandlesNV(VkDevice device,VkPipeline pipeline,uint32_t firstGroup,uint32_t groupCount,size_t dataSize,void * pData) const5008 bool ObjectLifetimes::PreCallValidateGetRayTracingShaderGroupHandlesNV(
5009 VkDevice device,
5010 VkPipeline pipeline,
5011 uint32_t firstGroup,
5012 uint32_t groupCount,
5013 size_t dataSize,
5014 void* pData) const {
5015 bool skip = false;
5016 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetRayTracingShaderGroupHandlesKHR-device-parameter", kVUIDUndefined);
5017 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, false, "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-parameter", "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-parent");
5018
5019 return skip;
5020 }
5021
PreCallValidateGetAccelerationStructureHandleNV(VkDevice device,VkAccelerationStructureKHR accelerationStructure,size_t dataSize,void * pData) const5022 bool ObjectLifetimes::PreCallValidateGetAccelerationStructureHandleNV(
5023 VkDevice device,
5024 VkAccelerationStructureKHR accelerationStructure,
5025 size_t dataSize,
5026 void* pData) const {
5027 bool skip = false;
5028 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetAccelerationStructureHandleNV-device-parameter", kVUIDUndefined);
5029 skip |= ValidateObject(accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parameter", "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parent");
5030
5031 return skip;
5032 }
5033
PreCallValidateCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer,uint32_t accelerationStructureCount,const VkAccelerationStructureKHR * pAccelerationStructures,VkQueryType queryType,VkQueryPool queryPool,uint32_t firstQuery) const5034 bool ObjectLifetimes::PreCallValidateCmdWriteAccelerationStructuresPropertiesKHR(
5035 VkCommandBuffer commandBuffer,
5036 uint32_t accelerationStructureCount,
5037 const VkAccelerationStructureKHR* pAccelerationStructures,
5038 VkQueryType queryType,
5039 VkQueryPool queryPool,
5040 uint32_t firstQuery) const {
5041 bool skip = false;
5042 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commandBuffer-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commonparent");
5043 if (pAccelerationStructures) {
5044 for (uint32_t index0 = 0; index0 < accelerationStructureCount; ++index0) {
5045 skip |= ValidateObject(pAccelerationStructures[index0], kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-pAccelerationStructures-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commonparent");
5046 }
5047 }
5048 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-queryPool-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commonparent");
5049
5050 return skip;
5051 }
5052
PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer,uint32_t accelerationStructureCount,const VkAccelerationStructureKHR * pAccelerationStructures,VkQueryType queryType,VkQueryPool queryPool,uint32_t firstQuery) const5053 bool ObjectLifetimes::PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(
5054 VkCommandBuffer commandBuffer,
5055 uint32_t accelerationStructureCount,
5056 const VkAccelerationStructureKHR* pAccelerationStructures,
5057 VkQueryType queryType,
5058 VkQueryPool queryPool,
5059 uint32_t firstQuery) const {
5060 bool skip = false;
5061 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commandBuffer-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commonparent");
5062 if (pAccelerationStructures) {
5063 for (uint32_t index0 = 0; index0 < accelerationStructureCount; ++index0) {
5064 skip |= ValidateObject(pAccelerationStructures[index0], kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-pAccelerationStructures-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commonparent");
5065 }
5066 }
5067 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-queryPool-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commonparent");
5068
5069 return skip;
5070 }
5071
PreCallValidateCompileDeferredNV(VkDevice device,VkPipeline pipeline,uint32_t shader) const5072 bool ObjectLifetimes::PreCallValidateCompileDeferredNV(
5073 VkDevice device,
5074 VkPipeline pipeline,
5075 uint32_t shader) const {
5076 bool skip = false;
5077 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCompileDeferredNV-device-parameter", kVUIDUndefined);
5078 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, false, "VUID-vkCompileDeferredNV-pipeline-parameter", "VUID-vkCompileDeferredNV-pipeline-parent");
5079
5080 return skip;
5081 }
5082
PreCallValidateGetMemoryHostPointerPropertiesEXT(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,const void * pHostPointer,VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties) const5083 bool ObjectLifetimes::PreCallValidateGetMemoryHostPointerPropertiesEXT(
5084 VkDevice device,
5085 VkExternalMemoryHandleTypeFlagBits handleType,
5086 const void* pHostPointer,
5087 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) const {
5088 bool skip = false;
5089 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter", kVUIDUndefined);
5090
5091 return skip;
5092 }
5093
PreCallValidateCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,VkPipelineStageFlagBits pipelineStage,VkBuffer dstBuffer,VkDeviceSize dstOffset,uint32_t marker) const5094 bool ObjectLifetimes::PreCallValidateCmdWriteBufferMarkerAMD(
5095 VkCommandBuffer commandBuffer,
5096 VkPipelineStageFlagBits pipelineStage,
5097 VkBuffer dstBuffer,
5098 VkDeviceSize dstOffset,
5099 uint32_t marker) const {
5100 bool skip = false;
5101 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter", "VUID-vkCmdWriteBufferMarkerAMD-commonparent");
5102 skip |= ValidateObject(dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter", "VUID-vkCmdWriteBufferMarkerAMD-commonparent");
5103
5104 return skip;
5105 }
5106
PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains) const5107 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(
5108 VkPhysicalDevice physicalDevice,
5109 uint32_t* pTimeDomainCount,
5110 VkTimeDomainEXT* pTimeDomains) const {
5111 bool skip = false;
5112 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-physicalDevice-parameter", kVUIDUndefined);
5113
5114 return skip;
5115 }
5116
PreCallValidateGetCalibratedTimestampsEXT(VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation) const5117 bool ObjectLifetimes::PreCallValidateGetCalibratedTimestampsEXT(
5118 VkDevice device,
5119 uint32_t timestampCount,
5120 const VkCalibratedTimestampInfoEXT* pTimestampInfos,
5121 uint64_t* pTimestamps,
5122 uint64_t* pMaxDeviation) const {
5123 bool skip = false;
5124 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetCalibratedTimestampsEXT-device-parameter", kVUIDUndefined);
5125
5126 return skip;
5127 }
5128
PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer,uint32_t taskCount,uint32_t firstTask) const5129 bool ObjectLifetimes::PreCallValidateCmdDrawMeshTasksNV(
5130 VkCommandBuffer commandBuffer,
5131 uint32_t taskCount,
5132 uint32_t firstTask) const {
5133 bool skip = false;
5134 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawMeshTasksNV-commandBuffer-parameter", kVUIDUndefined);
5135
5136 return skip;
5137 }
5138
PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const5139 bool ObjectLifetimes::PreCallValidateCmdDrawMeshTasksIndirectNV(
5140 VkCommandBuffer commandBuffer,
5141 VkBuffer buffer,
5142 VkDeviceSize offset,
5143 uint32_t drawCount,
5144 uint32_t stride) const {
5145 bool skip = false;
5146 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectNV-commonparent");
5147 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectNV-commonparent");
5148
5149 return skip;
5150 }
5151
PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const5152 bool ObjectLifetimes::PreCallValidateCmdDrawMeshTasksIndirectCountNV(
5153 VkCommandBuffer commandBuffer,
5154 VkBuffer buffer,
5155 VkDeviceSize offset,
5156 VkBuffer countBuffer,
5157 VkDeviceSize countBufferOffset,
5158 uint32_t maxDrawCount,
5159 uint32_t stride) const {
5160 bool skip = false;
5161 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent");
5162 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent");
5163 skip |= ValidateObject(countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent");
5164
5165 return skip;
5166 }
5167
PreCallValidateCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,uint32_t firstExclusiveScissor,uint32_t exclusiveScissorCount,const VkRect2D * pExclusiveScissors) const5168 bool ObjectLifetimes::PreCallValidateCmdSetExclusiveScissorNV(
5169 VkCommandBuffer commandBuffer,
5170 uint32_t firstExclusiveScissor,
5171 uint32_t exclusiveScissorCount,
5172 const VkRect2D* pExclusiveScissors) const {
5173 bool skip = false;
5174 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetExclusiveScissorNV-commandBuffer-parameter", kVUIDUndefined);
5175
5176 return skip;
5177 }
5178
PreCallValidateCmdSetCheckpointNV(VkCommandBuffer commandBuffer,const void * pCheckpointMarker) const5179 bool ObjectLifetimes::PreCallValidateCmdSetCheckpointNV(
5180 VkCommandBuffer commandBuffer,
5181 const void* pCheckpointMarker) const {
5182 bool skip = false;
5183 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetCheckpointNV-commandBuffer-parameter", kVUIDUndefined);
5184
5185 return skip;
5186 }
5187
PreCallValidateGetQueueCheckpointDataNV(VkQueue queue,uint32_t * pCheckpointDataCount,VkCheckpointDataNV * pCheckpointData) const5188 bool ObjectLifetimes::PreCallValidateGetQueueCheckpointDataNV(
5189 VkQueue queue,
5190 uint32_t* pCheckpointDataCount,
5191 VkCheckpointDataNV* pCheckpointData) const {
5192 bool skip = false;
5193 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkGetQueueCheckpointDataNV-queue-parameter", kVUIDUndefined);
5194
5195 return skip;
5196 }
5197
PreCallValidateInitializePerformanceApiINTEL(VkDevice device,const VkInitializePerformanceApiInfoINTEL * pInitializeInfo) const5198 bool ObjectLifetimes::PreCallValidateInitializePerformanceApiINTEL(
5199 VkDevice device,
5200 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) const {
5201 bool skip = false;
5202 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkInitializePerformanceApiINTEL-device-parameter", kVUIDUndefined);
5203
5204 return skip;
5205 }
5206
PreCallValidateUninitializePerformanceApiINTEL(VkDevice device) const5207 bool ObjectLifetimes::PreCallValidateUninitializePerformanceApiINTEL(
5208 VkDevice device) const {
5209 bool skip = false;
5210 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkUninitializePerformanceApiINTEL-device-parameter", kVUIDUndefined);
5211
5212 return skip;
5213 }
5214
PreCallValidateCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer,const VkPerformanceMarkerInfoINTEL * pMarkerInfo) const5215 bool ObjectLifetimes::PreCallValidateCmdSetPerformanceMarkerINTEL(
5216 VkCommandBuffer commandBuffer,
5217 const VkPerformanceMarkerInfoINTEL* pMarkerInfo) const {
5218 bool skip = false;
5219 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetPerformanceMarkerINTEL-commandBuffer-parameter", kVUIDUndefined);
5220
5221 return skip;
5222 }
5223
PreCallValidateCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo) const5224 bool ObjectLifetimes::PreCallValidateCmdSetPerformanceStreamMarkerINTEL(
5225 VkCommandBuffer commandBuffer,
5226 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) const {
5227 bool skip = false;
5228 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetPerformanceStreamMarkerINTEL-commandBuffer-parameter", kVUIDUndefined);
5229
5230 return skip;
5231 }
5232
PreCallValidateCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer,const VkPerformanceOverrideInfoINTEL * pOverrideInfo) const5233 bool ObjectLifetimes::PreCallValidateCmdSetPerformanceOverrideINTEL(
5234 VkCommandBuffer commandBuffer,
5235 const VkPerformanceOverrideInfoINTEL* pOverrideInfo) const {
5236 bool skip = false;
5237 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetPerformanceOverrideINTEL-commandBuffer-parameter", kVUIDUndefined);
5238
5239 return skip;
5240 }
5241
PreCallValidateAcquirePerformanceConfigurationINTEL(VkDevice device,const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,VkPerformanceConfigurationINTEL * pConfiguration) const5242 bool ObjectLifetimes::PreCallValidateAcquirePerformanceConfigurationINTEL(
5243 VkDevice device,
5244 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
5245 VkPerformanceConfigurationINTEL* pConfiguration) const {
5246 bool skip = false;
5247 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkAcquirePerformanceConfigurationINTEL-device-parameter", kVUIDUndefined);
5248
5249 return skip;
5250 }
5251
PostCallRecordAcquirePerformanceConfigurationINTEL(VkDevice device,const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,VkPerformanceConfigurationINTEL * pConfiguration,VkResult result)5252 void ObjectLifetimes::PostCallRecordAcquirePerformanceConfigurationINTEL(
5253 VkDevice device,
5254 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
5255 VkPerformanceConfigurationINTEL* pConfiguration,
5256 VkResult result) {
5257 if (result != VK_SUCCESS) return;
5258 CreateObject(*pConfiguration, kVulkanObjectTypePerformanceConfigurationINTEL, nullptr);
5259
5260 }
5261
PreCallValidateReleasePerformanceConfigurationINTEL(VkDevice device,VkPerformanceConfigurationINTEL configuration) const5262 bool ObjectLifetimes::PreCallValidateReleasePerformanceConfigurationINTEL(
5263 VkDevice device,
5264 VkPerformanceConfigurationINTEL configuration) const {
5265 bool skip = false;
5266 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkReleasePerformanceConfigurationINTEL-device-parameter", kVUIDUndefined);
5267 skip |= ValidateObject(configuration, kVulkanObjectTypePerformanceConfigurationINTEL, true, "VUID-vkReleasePerformanceConfigurationINTEL-configuration-parameter", "VUID-vkReleasePerformanceConfigurationINTEL-configuration-parent");
5268 skip |= ValidateDestroyObject(configuration, kVulkanObjectTypePerformanceConfigurationINTEL, nullptr, kVUIDUndefined, kVUIDUndefined);
5269
5270 return skip;
5271 }
5272
PreCallRecordReleasePerformanceConfigurationINTEL(VkDevice device,VkPerformanceConfigurationINTEL configuration)5273 void ObjectLifetimes::PreCallRecordReleasePerformanceConfigurationINTEL(
5274 VkDevice device,
5275 VkPerformanceConfigurationINTEL configuration) {
5276 RecordDestroyObject(configuration, kVulkanObjectTypePerformanceConfigurationINTEL);
5277
5278 }
5279
PreCallValidateQueueSetPerformanceConfigurationINTEL(VkQueue queue,VkPerformanceConfigurationINTEL configuration) const5280 bool ObjectLifetimes::PreCallValidateQueueSetPerformanceConfigurationINTEL(
5281 VkQueue queue,
5282 VkPerformanceConfigurationINTEL configuration) const {
5283 bool skip = false;
5284 skip |= ValidateObject(queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueSetPerformanceConfigurationINTEL-queue-parameter", "VUID-vkQueueSetPerformanceConfigurationINTEL-commonparent");
5285 skip |= ValidateObject(configuration, kVulkanObjectTypePerformanceConfigurationINTEL, false, "VUID-vkQueueSetPerformanceConfigurationINTEL-configuration-parameter", "VUID-vkQueueSetPerformanceConfigurationINTEL-commonparent");
5286
5287 return skip;
5288 }
5289
PreCallValidateGetPerformanceParameterINTEL(VkDevice device,VkPerformanceParameterTypeINTEL parameter,VkPerformanceValueINTEL * pValue) const5290 bool ObjectLifetimes::PreCallValidateGetPerformanceParameterINTEL(
5291 VkDevice device,
5292 VkPerformanceParameterTypeINTEL parameter,
5293 VkPerformanceValueINTEL* pValue) const {
5294 bool skip = false;
5295 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetPerformanceParameterINTEL-device-parameter", kVUIDUndefined);
5296
5297 return skip;
5298 }
5299
PreCallValidateSetLocalDimmingAMD(VkDevice device,VkSwapchainKHR swapChain,VkBool32 localDimmingEnable) const5300 bool ObjectLifetimes::PreCallValidateSetLocalDimmingAMD(
5301 VkDevice device,
5302 VkSwapchainKHR swapChain,
5303 VkBool32 localDimmingEnable) const {
5304 bool skip = false;
5305 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkSetLocalDimmingAMD-device-parameter", "VUID-vkSetLocalDimmingAMD-commonparent");
5306 skip |= ValidateObject(swapChain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkSetLocalDimmingAMD-swapChain-parameter", "VUID-vkSetLocalDimmingAMD-commonparent");
5307
5308 return skip;
5309 }
5310
5311 #ifdef VK_USE_PLATFORM_FUCHSIA
5312
PreCallValidateCreateImagePipeSurfaceFUCHSIA(VkInstance instance,const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const5313 bool ObjectLifetimes::PreCallValidateCreateImagePipeSurfaceFUCHSIA(
5314 VkInstance instance,
5315 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
5316 const VkAllocationCallbacks* pAllocator,
5317 VkSurfaceKHR* pSurface) const {
5318 bool skip = false;
5319 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateImagePipeSurfaceFUCHSIA-instance-parameter", kVUIDUndefined);
5320
5321 return skip;
5322 }
5323
PostCallRecordCreateImagePipeSurfaceFUCHSIA(VkInstance instance,const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)5324 void ObjectLifetimes::PostCallRecordCreateImagePipeSurfaceFUCHSIA(
5325 VkInstance instance,
5326 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
5327 const VkAllocationCallbacks* pAllocator,
5328 VkSurfaceKHR* pSurface,
5329 VkResult result) {
5330 if (result != VK_SUCCESS) return;
5331 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
5332
5333 }
5334 #endif // VK_USE_PLATFORM_FUCHSIA
5335
5336 #ifdef VK_USE_PLATFORM_METAL_EXT
5337
PreCallValidateCreateMetalSurfaceEXT(VkInstance instance,const VkMetalSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const5338 bool ObjectLifetimes::PreCallValidateCreateMetalSurfaceEXT(
5339 VkInstance instance,
5340 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
5341 const VkAllocationCallbacks* pAllocator,
5342 VkSurfaceKHR* pSurface) const {
5343 bool skip = false;
5344 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateMetalSurfaceEXT-instance-parameter", kVUIDUndefined);
5345
5346 return skip;
5347 }
5348
PostCallRecordCreateMetalSurfaceEXT(VkInstance instance,const VkMetalSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)5349 void ObjectLifetimes::PostCallRecordCreateMetalSurfaceEXT(
5350 VkInstance instance,
5351 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
5352 const VkAllocationCallbacks* pAllocator,
5353 VkSurfaceKHR* pSurface,
5354 VkResult result) {
5355 if (result != VK_SUCCESS) return;
5356 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
5357
5358 }
5359 #endif // VK_USE_PLATFORM_METAL_EXT
5360
PreCallValidateGetBufferDeviceAddressEXT(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const5361 bool ObjectLifetimes::PreCallValidateGetBufferDeviceAddressEXT(
5362 VkDevice device,
5363 const VkBufferDeviceAddressInfo* pInfo) const {
5364 bool skip = false;
5365 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferDeviceAddress-device-parameter", kVUIDUndefined);
5366
5367 return skip;
5368 }
5369
PreCallValidateGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolPropertiesEXT * pToolProperties) const5370 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceToolPropertiesEXT(
5371 VkPhysicalDevice physicalDevice,
5372 uint32_t* pToolCount,
5373 VkPhysicalDeviceToolPropertiesEXT* pToolProperties) const {
5374 bool skip = false;
5375 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceToolPropertiesEXT-physicalDevice-parameter", kVUIDUndefined);
5376
5377 return skip;
5378 }
5379
PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkCooperativeMatrixPropertiesNV * pProperties) const5380 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(
5381 VkPhysicalDevice physicalDevice,
5382 uint32_t* pPropertyCount,
5383 VkCooperativeMatrixPropertiesNV* pProperties) const {
5384 bool skip = false;
5385 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceCooperativeMatrixPropertiesNV-physicalDevice-parameter", kVUIDUndefined);
5386
5387 return skip;
5388 }
5389
PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice,uint32_t * pCombinationCount,VkFramebufferMixedSamplesCombinationNV * pCombinations) const5390 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
5391 VkPhysicalDevice physicalDevice,
5392 uint32_t* pCombinationCount,
5393 VkFramebufferMixedSamplesCombinationNV* pCombinations) const {
5394 bool skip = false;
5395 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV-physicalDevice-parameter", kVUIDUndefined);
5396
5397 return skip;
5398 }
5399
5400 #ifdef VK_USE_PLATFORM_WIN32_KHR
5401
PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,uint32_t * pPresentModeCount,VkPresentModeKHR * pPresentModes) const5402 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT(
5403 VkPhysicalDevice physicalDevice,
5404 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
5405 uint32_t* pPresentModeCount,
5406 VkPresentModeKHR* pPresentModes) const {
5407 bool skip = false;
5408 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter", kVUIDUndefined);
5409 if (pSurfaceInfo) {
5410 skip |= ValidateObject(pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
5411 }
5412
5413 return skip;
5414 }
5415 #endif // VK_USE_PLATFORM_WIN32_KHR
5416
5417 #ifdef VK_USE_PLATFORM_WIN32_KHR
5418
PreCallValidateAcquireFullScreenExclusiveModeEXT(VkDevice device,VkSwapchainKHR swapchain) const5419 bool ObjectLifetimes::PreCallValidateAcquireFullScreenExclusiveModeEXT(
5420 VkDevice device,
5421 VkSwapchainKHR swapchain) const {
5422 bool skip = false;
5423 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkAcquireFullScreenExclusiveModeEXT-device-parameter", "VUID-vkAcquireFullScreenExclusiveModeEXT-commonparent");
5424 skip |= ValidateObject(swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-parameter", "VUID-vkAcquireFullScreenExclusiveModeEXT-commonparent");
5425
5426 return skip;
5427 }
5428 #endif // VK_USE_PLATFORM_WIN32_KHR
5429
5430 #ifdef VK_USE_PLATFORM_WIN32_KHR
5431
PreCallValidateReleaseFullScreenExclusiveModeEXT(VkDevice device,VkSwapchainKHR swapchain) const5432 bool ObjectLifetimes::PreCallValidateReleaseFullScreenExclusiveModeEXT(
5433 VkDevice device,
5434 VkSwapchainKHR swapchain) const {
5435 bool skip = false;
5436 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
5437 skip |= ValidateObject(swapchain, kVulkanObjectTypeSwapchainKHR, false, kVUIDUndefined, kVUIDUndefined);
5438
5439 return skip;
5440 }
5441 #endif // VK_USE_PLATFORM_WIN32_KHR
5442
5443 #ifdef VK_USE_PLATFORM_WIN32_KHR
5444
PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(VkDevice device,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,VkDeviceGroupPresentModeFlagsKHR * pModes) const5445 bool ObjectLifetimes::PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(
5446 VkDevice device,
5447 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
5448 VkDeviceGroupPresentModeFlagsKHR* pModes) const {
5449 bool skip = false;
5450 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupSurfacePresentModes2EXT-device-parameter", kVUIDUndefined);
5451 if (pSurfaceInfo) {
5452 skip |= ValidateObject(pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
5453 }
5454
5455 return skip;
5456 }
5457 #endif // VK_USE_PLATFORM_WIN32_KHR
5458
PreCallValidateCreateHeadlessSurfaceEXT(VkInstance instance,const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const5459 bool ObjectLifetimes::PreCallValidateCreateHeadlessSurfaceEXT(
5460 VkInstance instance,
5461 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
5462 const VkAllocationCallbacks* pAllocator,
5463 VkSurfaceKHR* pSurface) const {
5464 bool skip = false;
5465 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateHeadlessSurfaceEXT-instance-parameter", kVUIDUndefined);
5466
5467 return skip;
5468 }
5469
PostCallRecordCreateHeadlessSurfaceEXT(VkInstance instance,const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)5470 void ObjectLifetimes::PostCallRecordCreateHeadlessSurfaceEXT(
5471 VkInstance instance,
5472 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
5473 const VkAllocationCallbacks* pAllocator,
5474 VkSurfaceKHR* pSurface,
5475 VkResult result) {
5476 if (result != VK_SUCCESS) return;
5477 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
5478
5479 }
5480
PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,uint32_t lineStippleFactor,uint16_t lineStipplePattern) const5481 bool ObjectLifetimes::PreCallValidateCmdSetLineStippleEXT(
5482 VkCommandBuffer commandBuffer,
5483 uint32_t lineStippleFactor,
5484 uint16_t lineStipplePattern) const {
5485 bool skip = false;
5486 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter", kVUIDUndefined);
5487
5488 return skip;
5489 }
5490
PreCallValidateResetQueryPoolEXT(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const5491 bool ObjectLifetimes::PreCallValidateResetQueryPoolEXT(
5492 VkDevice device,
5493 VkQueryPool queryPool,
5494 uint32_t firstQuery,
5495 uint32_t queryCount) const {
5496 bool skip = false;
5497 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkResetQueryPool-device-parameter", kVUIDUndefined);
5498 skip |= ValidateObject(queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkResetQueryPool-queryPool-parameter", "VUID-vkResetQueryPool-queryPool-parent");
5499
5500 return skip;
5501 }
5502
PreCallValidateCmdSetCullModeEXT(VkCommandBuffer commandBuffer,VkCullModeFlags cullMode) const5503 bool ObjectLifetimes::PreCallValidateCmdSetCullModeEXT(
5504 VkCommandBuffer commandBuffer,
5505 VkCullModeFlags cullMode) const {
5506 bool skip = false;
5507 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetCullModeEXT-commandBuffer-parameter", kVUIDUndefined);
5508
5509 return skip;
5510 }
5511
PreCallValidateCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,VkFrontFace frontFace) const5512 bool ObjectLifetimes::PreCallValidateCmdSetFrontFaceEXT(
5513 VkCommandBuffer commandBuffer,
5514 VkFrontFace frontFace) const {
5515 bool skip = false;
5516 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetFrontFaceEXT-commandBuffer-parameter", kVUIDUndefined);
5517
5518 return skip;
5519 }
5520
PreCallValidateCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,VkPrimitiveTopology primitiveTopology) const5521 bool ObjectLifetimes::PreCallValidateCmdSetPrimitiveTopologyEXT(
5522 VkCommandBuffer commandBuffer,
5523 VkPrimitiveTopology primitiveTopology) const {
5524 bool skip = false;
5525 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetPrimitiveTopologyEXT-commandBuffer-parameter", kVUIDUndefined);
5526
5527 return skip;
5528 }
5529
PreCallValidateCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,uint32_t viewportCount,const VkViewport * pViewports) const5530 bool ObjectLifetimes::PreCallValidateCmdSetViewportWithCountEXT(
5531 VkCommandBuffer commandBuffer,
5532 uint32_t viewportCount,
5533 const VkViewport* pViewports) const {
5534 bool skip = false;
5535 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetViewportWithCountEXT-commandBuffer-parameter", kVUIDUndefined);
5536
5537 return skip;
5538 }
5539
PreCallValidateCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,uint32_t scissorCount,const VkRect2D * pScissors) const5540 bool ObjectLifetimes::PreCallValidateCmdSetScissorWithCountEXT(
5541 VkCommandBuffer commandBuffer,
5542 uint32_t scissorCount,
5543 const VkRect2D* pScissors) const {
5544 bool skip = false;
5545 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetScissorWithCountEXT-commandBuffer-parameter", kVUIDUndefined);
5546
5547 return skip;
5548 }
5549
PreCallValidateCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets,const VkDeviceSize * pSizes,const VkDeviceSize * pStrides) const5550 bool ObjectLifetimes::PreCallValidateCmdBindVertexBuffers2EXT(
5551 VkCommandBuffer commandBuffer,
5552 uint32_t firstBinding,
5553 uint32_t bindingCount,
5554 const VkBuffer* pBuffers,
5555 const VkDeviceSize* pOffsets,
5556 const VkDeviceSize* pSizes,
5557 const VkDeviceSize* pStrides) const {
5558 bool skip = false;
5559 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindVertexBuffers2EXT-commandBuffer-parameter", "VUID-vkCmdBindVertexBuffers2EXT-commonparent");
5560 if (pBuffers) {
5561 for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
5562 skip |= ValidateObject(pBuffers[index0], kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindVertexBuffers2EXT-pBuffers-parameter", "VUID-vkCmdBindVertexBuffers2EXT-commonparent");
5563 }
5564 }
5565
5566 return skip;
5567 }
5568
PreCallValidateCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthTestEnable) const5569 bool ObjectLifetimes::PreCallValidateCmdSetDepthTestEnableEXT(
5570 VkCommandBuffer commandBuffer,
5571 VkBool32 depthTestEnable) const {
5572 bool skip = false;
5573 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthTestEnableEXT-commandBuffer-parameter", kVUIDUndefined);
5574
5575 return skip;
5576 }
5577
PreCallValidateCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthWriteEnable) const5578 bool ObjectLifetimes::PreCallValidateCmdSetDepthWriteEnableEXT(
5579 VkCommandBuffer commandBuffer,
5580 VkBool32 depthWriteEnable) const {
5581 bool skip = false;
5582 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthWriteEnableEXT-commandBuffer-parameter", kVUIDUndefined);
5583
5584 return skip;
5585 }
5586
PreCallValidateCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,VkCompareOp depthCompareOp) const5587 bool ObjectLifetimes::PreCallValidateCmdSetDepthCompareOpEXT(
5588 VkCommandBuffer commandBuffer,
5589 VkCompareOp depthCompareOp) const {
5590 bool skip = false;
5591 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthCompareOpEXT-commandBuffer-parameter", kVUIDUndefined);
5592
5593 return skip;
5594 }
5595
PreCallValidateCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthBoundsTestEnable) const5596 bool ObjectLifetimes::PreCallValidateCmdSetDepthBoundsTestEnableEXT(
5597 VkCommandBuffer commandBuffer,
5598 VkBool32 depthBoundsTestEnable) const {
5599 bool skip = false;
5600 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthBoundsTestEnableEXT-commandBuffer-parameter", kVUIDUndefined);
5601
5602 return skip;
5603 }
5604
PreCallValidateCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 stencilTestEnable) const5605 bool ObjectLifetimes::PreCallValidateCmdSetStencilTestEnableEXT(
5606 VkCommandBuffer commandBuffer,
5607 VkBool32 stencilTestEnable) const {
5608 bool skip = false;
5609 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilTestEnableEXT-commandBuffer-parameter", kVUIDUndefined);
5610
5611 return skip;
5612 }
5613
PreCallValidateCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,VkStencilOp failOp,VkStencilOp passOp,VkStencilOp depthFailOp,VkCompareOp compareOp) const5614 bool ObjectLifetimes::PreCallValidateCmdSetStencilOpEXT(
5615 VkCommandBuffer commandBuffer,
5616 VkStencilFaceFlags faceMask,
5617 VkStencilOp failOp,
5618 VkStencilOp passOp,
5619 VkStencilOp depthFailOp,
5620 VkCompareOp compareOp) const {
5621 bool skip = false;
5622 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilOpEXT-commandBuffer-parameter", kVUIDUndefined);
5623
5624 return skip;
5625 }
5626
PreCallValidateGetGeneratedCommandsMemoryRequirementsNV(VkDevice device,const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const5627 bool ObjectLifetimes::PreCallValidateGetGeneratedCommandsMemoryRequirementsNV(
5628 VkDevice device,
5629 const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
5630 VkMemoryRequirements2* pMemoryRequirements) const {
5631 bool skip = false;
5632 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetGeneratedCommandsMemoryRequirementsNV-device-parameter", kVUIDUndefined);
5633 if (pInfo) {
5634 skip |= ValidateObject(pInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-pipeline-parameter", "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-commonparent");
5635 skip |= ValidateObject(pInfo->indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNV, false, "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-indirectCommandsLayout-parameter", "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-commonparent");
5636 }
5637
5638 return skip;
5639 }
5640
PreCallValidateCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer,const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo) const5641 bool ObjectLifetimes::PreCallValidateCmdPreprocessGeneratedCommandsNV(
5642 VkCommandBuffer commandBuffer,
5643 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const {
5644 bool skip = false;
5645 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdPreprocessGeneratedCommandsNV-commandBuffer-parameter", kVUIDUndefined);
5646 if (pGeneratedCommandsInfo) {
5647 skip |= ValidateObject(pGeneratedCommandsInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkGeneratedCommandsInfoNV-pipeline-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5648 skip |= ValidateObject(pGeneratedCommandsInfo->indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNV, false, "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5649 if (pGeneratedCommandsInfo->pStreams) {
5650 for (uint32_t index1 = 0; index1 < pGeneratedCommandsInfo->streamCount; ++index1) {
5651 skip |= ValidateObject(pGeneratedCommandsInfo->pStreams[index1].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkIndirectCommandsStreamNV-buffer-parameter", kVUIDUndefined);
5652 }
5653 }
5654 skip |= ValidateObject(pGeneratedCommandsInfo->preprocessBuffer, kVulkanObjectTypeBuffer, false, "VUID-VkGeneratedCommandsInfoNV-preprocessBuffer-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5655 skip |= ValidateObject(pGeneratedCommandsInfo->sequencesCountBuffer, kVulkanObjectTypeBuffer, true, "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5656 skip |= ValidateObject(pGeneratedCommandsInfo->sequencesIndexBuffer, kVulkanObjectTypeBuffer, true, "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5657 }
5658
5659 return skip;
5660 }
5661
PreCallValidateCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer,VkBool32 isPreprocessed,const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo) const5662 bool ObjectLifetimes::PreCallValidateCmdExecuteGeneratedCommandsNV(
5663 VkCommandBuffer commandBuffer,
5664 VkBool32 isPreprocessed,
5665 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const {
5666 bool skip = false;
5667 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-parameter", kVUIDUndefined);
5668 if (pGeneratedCommandsInfo) {
5669 skip |= ValidateObject(pGeneratedCommandsInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkGeneratedCommandsInfoNV-pipeline-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5670 skip |= ValidateObject(pGeneratedCommandsInfo->indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNV, false, "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5671 if (pGeneratedCommandsInfo->pStreams) {
5672 for (uint32_t index1 = 0; index1 < pGeneratedCommandsInfo->streamCount; ++index1) {
5673 skip |= ValidateObject(pGeneratedCommandsInfo->pStreams[index1].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkIndirectCommandsStreamNV-buffer-parameter", kVUIDUndefined);
5674 }
5675 }
5676 skip |= ValidateObject(pGeneratedCommandsInfo->preprocessBuffer, kVulkanObjectTypeBuffer, false, "VUID-VkGeneratedCommandsInfoNV-preprocessBuffer-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5677 skip |= ValidateObject(pGeneratedCommandsInfo->sequencesCountBuffer, kVulkanObjectTypeBuffer, true, "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5678 skip |= ValidateObject(pGeneratedCommandsInfo->sequencesIndexBuffer, kVulkanObjectTypeBuffer, true, "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-parameter", "VUID-VkGeneratedCommandsInfoNV-commonparent");
5679 }
5680
5681 return skip;
5682 }
5683
PreCallValidateCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipeline pipeline,uint32_t groupIndex) const5684 bool ObjectLifetimes::PreCallValidateCmdBindPipelineShaderGroupNV(
5685 VkCommandBuffer commandBuffer,
5686 VkPipelineBindPoint pipelineBindPoint,
5687 VkPipeline pipeline,
5688 uint32_t groupIndex) const {
5689 bool skip = false;
5690 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindPipelineShaderGroupNV-commandBuffer-parameter", "VUID-vkCmdBindPipelineShaderGroupNV-commonparent");
5691 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, false, "VUID-vkCmdBindPipelineShaderGroupNV-pipeline-parameter", "VUID-vkCmdBindPipelineShaderGroupNV-commonparent");
5692
5693 return skip;
5694 }
5695
PreCallValidateCreateIndirectCommandsLayoutNV(VkDevice device,const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkIndirectCommandsLayoutNV * pIndirectCommandsLayout) const5696 bool ObjectLifetimes::PreCallValidateCreateIndirectCommandsLayoutNV(
5697 VkDevice device,
5698 const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
5699 const VkAllocationCallbacks* pAllocator,
5700 VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) const {
5701 bool skip = false;
5702 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateIndirectCommandsLayoutNV-device-parameter", kVUIDUndefined);
5703 if (pCreateInfo) {
5704 if (pCreateInfo->pTokens) {
5705 for (uint32_t index1 = 0; index1 < pCreateInfo->tokenCount; ++index1) {
5706 skip |= ValidateObject(pCreateInfo->pTokens[index1].pushconstantPipelineLayout, kVulkanObjectTypePipelineLayout, true, "VUID-VkIndirectCommandsLayoutTokenNV-pushconstantPipelineLayout-parameter", kVUIDUndefined);
5707 }
5708 }
5709 }
5710
5711 return skip;
5712 }
5713
PostCallRecordCreateIndirectCommandsLayoutNV(VkDevice device,const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkIndirectCommandsLayoutNV * pIndirectCommandsLayout,VkResult result)5714 void ObjectLifetimes::PostCallRecordCreateIndirectCommandsLayoutNV(
5715 VkDevice device,
5716 const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
5717 const VkAllocationCallbacks* pAllocator,
5718 VkIndirectCommandsLayoutNV* pIndirectCommandsLayout,
5719 VkResult result) {
5720 if (result != VK_SUCCESS) return;
5721 CreateObject(*pIndirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNV, pAllocator);
5722
5723 }
5724
PreCallValidateDestroyIndirectCommandsLayoutNV(VkDevice device,VkIndirectCommandsLayoutNV indirectCommandsLayout,const VkAllocationCallbacks * pAllocator) const5725 bool ObjectLifetimes::PreCallValidateDestroyIndirectCommandsLayoutNV(
5726 VkDevice device,
5727 VkIndirectCommandsLayoutNV indirectCommandsLayout,
5728 const VkAllocationCallbacks* pAllocator) const {
5729 bool skip = false;
5730 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyIndirectCommandsLayoutNV-device-parameter", kVUIDUndefined);
5731 skip |= ValidateObject(indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNV, true, "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-parameter", "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-parent");
5732 skip |= ValidateDestroyObject(indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNV, pAllocator, kVUIDUndefined, kVUIDUndefined);
5733
5734 return skip;
5735 }
5736
PreCallRecordDestroyIndirectCommandsLayoutNV(VkDevice device,VkIndirectCommandsLayoutNV indirectCommandsLayout,const VkAllocationCallbacks * pAllocator)5737 void ObjectLifetimes::PreCallRecordDestroyIndirectCommandsLayoutNV(
5738 VkDevice device,
5739 VkIndirectCommandsLayoutNV indirectCommandsLayout,
5740 const VkAllocationCallbacks* pAllocator) {
5741 RecordDestroyObject(indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNV);
5742
5743 }
5744
PreCallValidateCreatePrivateDataSlotEXT(VkDevice device,const VkPrivateDataSlotCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPrivateDataSlotEXT * pPrivateDataSlot) const5745 bool ObjectLifetimes::PreCallValidateCreatePrivateDataSlotEXT(
5746 VkDevice device,
5747 const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
5748 const VkAllocationCallbacks* pAllocator,
5749 VkPrivateDataSlotEXT* pPrivateDataSlot) const {
5750 bool skip = false;
5751 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreatePrivateDataSlotEXT-device-parameter", kVUIDUndefined);
5752
5753 return skip;
5754 }
5755
PostCallRecordCreatePrivateDataSlotEXT(VkDevice device,const VkPrivateDataSlotCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPrivateDataSlotEXT * pPrivateDataSlot,VkResult result)5756 void ObjectLifetimes::PostCallRecordCreatePrivateDataSlotEXT(
5757 VkDevice device,
5758 const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
5759 const VkAllocationCallbacks* pAllocator,
5760 VkPrivateDataSlotEXT* pPrivateDataSlot,
5761 VkResult result) {
5762 if (result != VK_SUCCESS) return;
5763 CreateObject(*pPrivateDataSlot, kVulkanObjectTypePrivateDataSlotEXT, pAllocator);
5764
5765 }
5766
PreCallValidateDestroyPrivateDataSlotEXT(VkDevice device,VkPrivateDataSlotEXT privateDataSlot,const VkAllocationCallbacks * pAllocator) const5767 bool ObjectLifetimes::PreCallValidateDestroyPrivateDataSlotEXT(
5768 VkDevice device,
5769 VkPrivateDataSlotEXT privateDataSlot,
5770 const VkAllocationCallbacks* pAllocator) const {
5771 bool skip = false;
5772 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyPrivateDataSlotEXT-device-parameter", kVUIDUndefined);
5773 skip |= ValidateObject(privateDataSlot, kVulkanObjectTypePrivateDataSlotEXT, true, "VUID-vkDestroyPrivateDataSlotEXT-privateDataSlot-parameter", "VUID-vkDestroyPrivateDataSlotEXT-privateDataSlot-parent");
5774 skip |= ValidateDestroyObject(privateDataSlot, kVulkanObjectTypePrivateDataSlotEXT, pAllocator, kVUIDUndefined, kVUIDUndefined);
5775
5776 return skip;
5777 }
5778
PreCallRecordDestroyPrivateDataSlotEXT(VkDevice device,VkPrivateDataSlotEXT privateDataSlot,const VkAllocationCallbacks * pAllocator)5779 void ObjectLifetimes::PreCallRecordDestroyPrivateDataSlotEXT(
5780 VkDevice device,
5781 VkPrivateDataSlotEXT privateDataSlot,
5782 const VkAllocationCallbacks* pAllocator) {
5783 RecordDestroyObject(privateDataSlot, kVulkanObjectTypePrivateDataSlotEXT);
5784
5785 }
5786
PreCallValidateSetPrivateDataEXT(VkDevice device,VkObjectType objectType,uint64_t objectHandle,VkPrivateDataSlotEXT privateDataSlot,uint64_t data) const5787 bool ObjectLifetimes::PreCallValidateSetPrivateDataEXT(
5788 VkDevice device,
5789 VkObjectType objectType,
5790 uint64_t objectHandle,
5791 VkPrivateDataSlotEXT privateDataSlot,
5792 uint64_t data) const {
5793 bool skip = false;
5794 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkSetPrivateDataEXT-device-parameter", kVUIDUndefined);
5795 skip |= ValidateObject(privateDataSlot, kVulkanObjectTypePrivateDataSlotEXT, false, "VUID-vkSetPrivateDataEXT-privateDataSlot-parameter", "VUID-vkSetPrivateDataEXT-privateDataSlot-parent");
5796
5797 return skip;
5798 }
5799
PreCallValidateGetPrivateDataEXT(VkDevice device,VkObjectType objectType,uint64_t objectHandle,VkPrivateDataSlotEXT privateDataSlot,uint64_t * pData) const5800 bool ObjectLifetimes::PreCallValidateGetPrivateDataEXT(
5801 VkDevice device,
5802 VkObjectType objectType,
5803 uint64_t objectHandle,
5804 VkPrivateDataSlotEXT privateDataSlot,
5805 uint64_t* pData) const {
5806 bool skip = false;
5807 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetPrivateDataEXT-device-parameter", kVUIDUndefined);
5808 skip |= ValidateObject(privateDataSlot, kVulkanObjectTypePrivateDataSlotEXT, false, "VUID-vkGetPrivateDataEXT-privateDataSlot-parameter", "VUID-vkGetPrivateDataEXT-privateDataSlot-parent");
5809
5810 return skip;
5811 }
5812
5813 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
5814
PreCallValidateCreateDirectFBSurfaceEXT(VkInstance instance,const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const5815 bool ObjectLifetimes::PreCallValidateCreateDirectFBSurfaceEXT(
5816 VkInstance instance,
5817 const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
5818 const VkAllocationCallbacks* pAllocator,
5819 VkSurfaceKHR* pSurface) const {
5820 bool skip = false;
5821 skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateDirectFBSurfaceEXT-instance-parameter", kVUIDUndefined);
5822
5823 return skip;
5824 }
5825
PostCallRecordCreateDirectFBSurfaceEXT(VkInstance instance,const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface,VkResult result)5826 void ObjectLifetimes::PostCallRecordCreateDirectFBSurfaceEXT(
5827 VkInstance instance,
5828 const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
5829 const VkAllocationCallbacks* pAllocator,
5830 VkSurfaceKHR* pSurface,
5831 VkResult result) {
5832 if (result != VK_SUCCESS) return;
5833 CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
5834
5835 }
5836 #endif // VK_USE_PLATFORM_DIRECTFB_EXT
5837
5838 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
5839
PreCallValidateGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,IDirectFB * dfb) const5840 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDirectFBPresentationSupportEXT(
5841 VkPhysicalDevice physicalDevice,
5842 uint32_t queueFamilyIndex,
5843 IDirectFB* dfb) const {
5844 bool skip = false;
5845 skip |= ValidateObject(physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceDirectFBPresentationSupportEXT-physicalDevice-parameter", kVUIDUndefined);
5846
5847 return skip;
5848 }
5849 #endif // VK_USE_PLATFORM_DIRECTFB_EXT
5850
5851 #ifdef VK_ENABLE_BETA_EXTENSIONS
5852
PreCallValidateCreateAccelerationStructureKHR(VkDevice device,const VkAccelerationStructureCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkAccelerationStructureKHR * pAccelerationStructure) const5853 bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureKHR(
5854 VkDevice device,
5855 const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
5856 const VkAllocationCallbacks* pAllocator,
5857 VkAccelerationStructureKHR* pAccelerationStructure) const {
5858 bool skip = false;
5859 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateAccelerationStructureKHR-device-parameter", kVUIDUndefined);
5860
5861 return skip;
5862 }
5863
PostCallRecordCreateAccelerationStructureKHR(VkDevice device,const VkAccelerationStructureCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkAccelerationStructureKHR * pAccelerationStructure,VkResult result)5864 void ObjectLifetimes::PostCallRecordCreateAccelerationStructureKHR(
5865 VkDevice device,
5866 const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
5867 const VkAllocationCallbacks* pAllocator,
5868 VkAccelerationStructureKHR* pAccelerationStructure,
5869 VkResult result) {
5870 if (result != VK_SUCCESS) return;
5871 CreateObject(*pAccelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, pAllocator);
5872
5873 }
5874 #endif // VK_ENABLE_BETA_EXTENSIONS
5875
5876 #ifdef VK_ENABLE_BETA_EXTENSIONS
5877
PreCallValidateGetAccelerationStructureMemoryRequirementsKHR(VkDevice device,const VkAccelerationStructureMemoryRequirementsInfoKHR * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const5878 bool ObjectLifetimes::PreCallValidateGetAccelerationStructureMemoryRequirementsKHR(
5879 VkDevice device,
5880 const VkAccelerationStructureMemoryRequirementsInfoKHR* pInfo,
5881 VkMemoryRequirements2* pMemoryRequirements) const {
5882 bool skip = false;
5883 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetAccelerationStructureMemoryRequirementsKHR-device-parameter", kVUIDUndefined);
5884 if (pInfo) {
5885 skip |= ValidateObject(pInfo->accelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkAccelerationStructureMemoryRequirementsInfoKHR-accelerationStructure-parameter", kVUIDUndefined);
5886 }
5887
5888 return skip;
5889 }
5890 #endif // VK_ENABLE_BETA_EXTENSIONS
5891
5892 #ifdef VK_ENABLE_BETA_EXTENSIONS
5893
PreCallValidateCmdBuildAccelerationStructureKHR(VkCommandBuffer commandBuffer,uint32_t infoCount,const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,const VkAccelerationStructureBuildOffsetInfoKHR * const * ppOffsetInfos) const5894 bool ObjectLifetimes::PreCallValidateCmdBuildAccelerationStructureKHR(
5895 VkCommandBuffer commandBuffer,
5896 uint32_t infoCount,
5897 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
5898 const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos) const {
5899 bool skip = false;
5900 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBuildAccelerationStructureKHR-commandBuffer-parameter", kVUIDUndefined);
5901 if (pInfos) {
5902 for (uint32_t index0 = 0; index0 < infoCount; ++index0) {
5903 skip |= ValidateObject(pInfos[index0].srcAccelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, true, "VUID-VkAccelerationStructureBuildGeometryInfoKHR-srcAccelerationStructure-parameter", "VUID-VkAccelerationStructureBuildGeometryInfoKHR-commonparent");
5904 skip |= ValidateObject(pInfos[index0].dstAccelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkAccelerationStructureBuildGeometryInfoKHR-dstAccelerationStructure-parameter", "VUID-VkAccelerationStructureBuildGeometryInfoKHR-commonparent");
5905 }
5906 }
5907
5908 return skip;
5909 }
5910 #endif // VK_ENABLE_BETA_EXTENSIONS
5911
5912 #ifdef VK_ENABLE_BETA_EXTENSIONS
5913
PreCallValidateCmdBuildAccelerationStructureIndirectKHR(VkCommandBuffer commandBuffer,const VkAccelerationStructureBuildGeometryInfoKHR * pInfo,VkBuffer indirectBuffer,VkDeviceSize indirectOffset,uint32_t indirectStride) const5914 bool ObjectLifetimes::PreCallValidateCmdBuildAccelerationStructureIndirectKHR(
5915 VkCommandBuffer commandBuffer,
5916 const VkAccelerationStructureBuildGeometryInfoKHR* pInfo,
5917 VkBuffer indirectBuffer,
5918 VkDeviceSize indirectOffset,
5919 uint32_t indirectStride) const {
5920 bool skip = false;
5921 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBuildAccelerationStructureIndirectKHR-commandBuffer-parameter", "VUID-vkCmdBuildAccelerationStructureIndirectKHR-commonparent");
5922 if (pInfo) {
5923 skip |= ValidateObject(pInfo->srcAccelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, true, "VUID-VkAccelerationStructureBuildGeometryInfoKHR-srcAccelerationStructure-parameter", "VUID-VkAccelerationStructureBuildGeometryInfoKHR-commonparent");
5924 skip |= ValidateObject(pInfo->dstAccelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkAccelerationStructureBuildGeometryInfoKHR-dstAccelerationStructure-parameter", "VUID-VkAccelerationStructureBuildGeometryInfoKHR-commonparent");
5925 }
5926 skip |= ValidateObject(indirectBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdBuildAccelerationStructureIndirectKHR-indirectBuffer-parameter", "VUID-vkCmdBuildAccelerationStructureIndirectKHR-commonparent");
5927
5928 return skip;
5929 }
5930 #endif // VK_ENABLE_BETA_EXTENSIONS
5931
5932 #ifdef VK_ENABLE_BETA_EXTENSIONS
5933
PreCallValidateBuildAccelerationStructureKHR(VkDevice device,uint32_t infoCount,const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,const VkAccelerationStructureBuildOffsetInfoKHR * const * ppOffsetInfos) const5934 bool ObjectLifetimes::PreCallValidateBuildAccelerationStructureKHR(
5935 VkDevice device,
5936 uint32_t infoCount,
5937 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
5938 const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos) const {
5939 bool skip = false;
5940 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkBuildAccelerationStructureKHR-device-parameter", kVUIDUndefined);
5941 if (pInfos) {
5942 for (uint32_t index0 = 0; index0 < infoCount; ++index0) {
5943 skip |= ValidateObject(pInfos[index0].srcAccelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, true, "VUID-VkAccelerationStructureBuildGeometryInfoKHR-srcAccelerationStructure-parameter", "VUID-VkAccelerationStructureBuildGeometryInfoKHR-commonparent");
5944 skip |= ValidateObject(pInfos[index0].dstAccelerationStructure, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkAccelerationStructureBuildGeometryInfoKHR-dstAccelerationStructure-parameter", "VUID-VkAccelerationStructureBuildGeometryInfoKHR-commonparent");
5945 }
5946 }
5947
5948 return skip;
5949 }
5950 #endif // VK_ENABLE_BETA_EXTENSIONS
5951
5952 #ifdef VK_ENABLE_BETA_EXTENSIONS
5953
PreCallValidateCopyAccelerationStructureKHR(VkDevice device,const VkCopyAccelerationStructureInfoKHR * pInfo) const5954 bool ObjectLifetimes::PreCallValidateCopyAccelerationStructureKHR(
5955 VkDevice device,
5956 const VkCopyAccelerationStructureInfoKHR* pInfo) const {
5957 bool skip = false;
5958 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCopyAccelerationStructureKHR-device-parameter", kVUIDUndefined);
5959 if (pInfo) {
5960 skip |= ValidateObject(pInfo->src, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyAccelerationStructureInfoKHR-src-parameter", "VUID-VkCopyAccelerationStructureInfoKHR-commonparent");
5961 skip |= ValidateObject(pInfo->dst, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyAccelerationStructureInfoKHR-dst-parameter", "VUID-VkCopyAccelerationStructureInfoKHR-commonparent");
5962 }
5963
5964 return skip;
5965 }
5966 #endif // VK_ENABLE_BETA_EXTENSIONS
5967
5968 #ifdef VK_ENABLE_BETA_EXTENSIONS
5969
PreCallValidateCopyAccelerationStructureToMemoryKHR(VkDevice device,const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo) const5970 bool ObjectLifetimes::PreCallValidateCopyAccelerationStructureToMemoryKHR(
5971 VkDevice device,
5972 const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const {
5973 bool skip = false;
5974 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCopyAccelerationStructureToMemoryKHR-device-parameter", kVUIDUndefined);
5975 if (pInfo) {
5976 skip |= ValidateObject(pInfo->src, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyAccelerationStructureToMemoryInfoKHR-src-parameter", kVUIDUndefined);
5977 }
5978
5979 return skip;
5980 }
5981 #endif // VK_ENABLE_BETA_EXTENSIONS
5982
5983 #ifdef VK_ENABLE_BETA_EXTENSIONS
5984
PreCallValidateCopyMemoryToAccelerationStructureKHR(VkDevice device,const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo) const5985 bool ObjectLifetimes::PreCallValidateCopyMemoryToAccelerationStructureKHR(
5986 VkDevice device,
5987 const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const {
5988 bool skip = false;
5989 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCopyMemoryToAccelerationStructureKHR-device-parameter", kVUIDUndefined);
5990 if (pInfo) {
5991 skip |= ValidateObject(pInfo->dst, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-dst-parameter", kVUIDUndefined);
5992 }
5993
5994 return skip;
5995 }
5996 #endif // VK_ENABLE_BETA_EXTENSIONS
5997
5998 #ifdef VK_ENABLE_BETA_EXTENSIONS
5999
PreCallValidateWriteAccelerationStructuresPropertiesKHR(VkDevice device,uint32_t accelerationStructureCount,const VkAccelerationStructureKHR * pAccelerationStructures,VkQueryType queryType,size_t dataSize,void * pData,size_t stride) const6000 bool ObjectLifetimes::PreCallValidateWriteAccelerationStructuresPropertiesKHR(
6001 VkDevice device,
6002 uint32_t accelerationStructureCount,
6003 const VkAccelerationStructureKHR* pAccelerationStructures,
6004 VkQueryType queryType,
6005 size_t dataSize,
6006 void* pData,
6007 size_t stride) const {
6008 bool skip = false;
6009 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkWriteAccelerationStructuresPropertiesKHR-device-parameter", kVUIDUndefined);
6010 if (pAccelerationStructures) {
6011 for (uint32_t index0 = 0; index0 < accelerationStructureCount; ++index0) {
6012 skip |= ValidateObject(pAccelerationStructures[index0], kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-vkWriteAccelerationStructuresPropertiesKHR-pAccelerationStructures-parameter", "VUID-vkWriteAccelerationStructuresPropertiesKHR-pAccelerationStructures-parent");
6013 }
6014 }
6015
6016 return skip;
6017 }
6018 #endif // VK_ENABLE_BETA_EXTENSIONS
6019
6020 #ifdef VK_ENABLE_BETA_EXTENSIONS
6021
PreCallValidateCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer,const VkCopyAccelerationStructureInfoKHR * pInfo) const6022 bool ObjectLifetimes::PreCallValidateCmdCopyAccelerationStructureKHR(
6023 VkCommandBuffer commandBuffer,
6024 const VkCopyAccelerationStructureInfoKHR* pInfo) const {
6025 bool skip = false;
6026 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyAccelerationStructureKHR-commandBuffer-parameter", kVUIDUndefined);
6027 if (pInfo) {
6028 skip |= ValidateObject(pInfo->src, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyAccelerationStructureInfoKHR-src-parameter", "VUID-VkCopyAccelerationStructureInfoKHR-commonparent");
6029 skip |= ValidateObject(pInfo->dst, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyAccelerationStructureInfoKHR-dst-parameter", "VUID-VkCopyAccelerationStructureInfoKHR-commonparent");
6030 }
6031
6032 return skip;
6033 }
6034 #endif // VK_ENABLE_BETA_EXTENSIONS
6035
6036 #ifdef VK_ENABLE_BETA_EXTENSIONS
6037
PreCallValidateCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer,const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo) const6038 bool ObjectLifetimes::PreCallValidateCmdCopyAccelerationStructureToMemoryKHR(
6039 VkCommandBuffer commandBuffer,
6040 const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const {
6041 bool skip = false;
6042 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-commandBuffer-parameter", kVUIDUndefined);
6043 if (pInfo) {
6044 skip |= ValidateObject(pInfo->src, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyAccelerationStructureToMemoryInfoKHR-src-parameter", kVUIDUndefined);
6045 }
6046
6047 return skip;
6048 }
6049 #endif // VK_ENABLE_BETA_EXTENSIONS
6050
6051 #ifdef VK_ENABLE_BETA_EXTENSIONS
6052
PreCallValidateCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer,const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo) const6053 bool ObjectLifetimes::PreCallValidateCmdCopyMemoryToAccelerationStructureKHR(
6054 VkCommandBuffer commandBuffer,
6055 const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const {
6056 bool skip = false;
6057 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-commandBuffer-parameter", kVUIDUndefined);
6058 if (pInfo) {
6059 skip |= ValidateObject(pInfo->dst, kVulkanObjectTypeAccelerationStructureKHR, false, "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-dst-parameter", kVUIDUndefined);
6060 }
6061
6062 return skip;
6063 }
6064 #endif // VK_ENABLE_BETA_EXTENSIONS
6065
6066 #ifdef VK_ENABLE_BETA_EXTENSIONS
6067
PreCallValidateCmdTraceRaysKHR(VkCommandBuffer commandBuffer,const VkStridedBufferRegionKHR * pRaygenShaderBindingTable,const VkStridedBufferRegionKHR * pMissShaderBindingTable,const VkStridedBufferRegionKHR * pHitShaderBindingTable,const VkStridedBufferRegionKHR * pCallableShaderBindingTable,uint32_t width,uint32_t height,uint32_t depth) const6068 bool ObjectLifetimes::PreCallValidateCmdTraceRaysKHR(
6069 VkCommandBuffer commandBuffer,
6070 const VkStridedBufferRegionKHR* pRaygenShaderBindingTable,
6071 const VkStridedBufferRegionKHR* pMissShaderBindingTable,
6072 const VkStridedBufferRegionKHR* pHitShaderBindingTable,
6073 const VkStridedBufferRegionKHR* pCallableShaderBindingTable,
6074 uint32_t width,
6075 uint32_t height,
6076 uint32_t depth) const {
6077 bool skip = false;
6078 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdTraceRaysKHR-commandBuffer-parameter", kVUIDUndefined);
6079 if (pRaygenShaderBindingTable) {
6080 skip |= ValidateObject(pRaygenShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6081 }
6082 if (pMissShaderBindingTable) {
6083 skip |= ValidateObject(pMissShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6084 }
6085 if (pHitShaderBindingTable) {
6086 skip |= ValidateObject(pHitShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6087 }
6088 if (pCallableShaderBindingTable) {
6089 skip |= ValidateObject(pCallableShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6090 }
6091
6092 return skip;
6093 }
6094 #endif // VK_ENABLE_BETA_EXTENSIONS
6095
6096 #ifdef VK_ENABLE_BETA_EXTENSIONS
6097
PreCallValidateCreateRayTracingPipelinesKHR(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const6098 bool ObjectLifetimes::PreCallValidateCreateRayTracingPipelinesKHR(
6099 VkDevice device,
6100 VkPipelineCache pipelineCache,
6101 uint32_t createInfoCount,
6102 const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
6103 const VkAllocationCallbacks* pAllocator,
6104 VkPipeline* pPipelines) const {
6105 bool skip = false;
6106 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRayTracingPipelinesKHR-device-parameter", kVUIDUndefined);
6107 skip |= ValidateObject(pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-parameter", "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-parent");
6108 if (pCreateInfos) {
6109 for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
6110 if (pCreateInfos[index0].pStages) {
6111 for (uint32_t index1 = 0; index1 < pCreateInfos[index0].stageCount; ++index1) {
6112 skip |= ValidateObject(pCreateInfos[index0].pStages[index1].module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
6113 }
6114 }
6115 if (pCreateInfos[index0].libraries.pLibraries) {
6116 for (uint32_t index2 = 0; index2 < pCreateInfos[index0].libraries.libraryCount; ++index2) {
6117 skip |= ValidateObject(pCreateInfos[index0].libraries.pLibraries[index2], kVulkanObjectTypePipeline, false, "VUID-VkPipelineLibraryCreateInfoKHR-pLibraries-parameter", kVUIDUndefined);
6118 }
6119 }
6120 skip |= ValidateObject(pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkRayTracingPipelineCreateInfoKHR-layout-parameter", "VUID-VkRayTracingPipelineCreateInfoKHR-commonparent");
6121 if ((pCreateInfos[index0].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) && (pCreateInfos[index0].basePipelineIndex == -1))
6122 skip |= ValidateObject(pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, false, "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03421", "VUID-VkRayTracingPipelineCreateInfoKHR-commonparent");
6123 }
6124 }
6125
6126 return skip;
6127 }
6128
PostCallRecordCreateRayTracingPipelinesKHR(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,VkResult result)6129 void ObjectLifetimes::PostCallRecordCreateRayTracingPipelinesKHR(
6130 VkDevice device,
6131 VkPipelineCache pipelineCache,
6132 uint32_t createInfoCount,
6133 const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
6134 const VkAllocationCallbacks* pAllocator,
6135 VkPipeline* pPipelines,
6136 VkResult result) {
6137 if (VK_ERROR_VALIDATION_FAILED_EXT == result) return;
6138 if (pPipelines) {
6139 for (uint32_t index = 0; index < createInfoCount; index++) {
6140 if (!pPipelines[index]) continue;
6141 CreateObject(pPipelines[index], kVulkanObjectTypePipeline, pAllocator);
6142 }
6143 }
6144
6145 }
6146 #endif // VK_ENABLE_BETA_EXTENSIONS
6147
6148 #ifdef VK_ENABLE_BETA_EXTENSIONS
6149
PreCallValidateGetAccelerationStructureDeviceAddressKHR(VkDevice device,const VkAccelerationStructureDeviceAddressInfoKHR * pInfo) const6150 bool ObjectLifetimes::PreCallValidateGetAccelerationStructureDeviceAddressKHR(
6151 VkDevice device,
6152 const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) const {
6153 bool skip = false;
6154 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetAccelerationStructureDeviceAddressKHR-device-parameter", kVUIDUndefined);
6155
6156 return skip;
6157 }
6158 #endif // VK_ENABLE_BETA_EXTENSIONS
6159
6160 #ifdef VK_ENABLE_BETA_EXTENSIONS
6161
PreCallValidateGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device,VkPipeline pipeline,uint32_t firstGroup,uint32_t groupCount,size_t dataSize,void * pData) const6162 bool ObjectLifetimes::PreCallValidateGetRayTracingCaptureReplayShaderGroupHandlesKHR(
6163 VkDevice device,
6164 VkPipeline pipeline,
6165 uint32_t firstGroup,
6166 uint32_t groupCount,
6167 size_t dataSize,
6168 void* pData) const {
6169 bool skip = false;
6170 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-device-parameter", kVUIDUndefined);
6171 skip |= ValidateObject(pipeline, kVulkanObjectTypePipeline, false, "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-parameter", "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-parent");
6172
6173 return skip;
6174 }
6175 #endif // VK_ENABLE_BETA_EXTENSIONS
6176
6177 #ifdef VK_ENABLE_BETA_EXTENSIONS
6178
PreCallValidateCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,const VkStridedBufferRegionKHR * pRaygenShaderBindingTable,const VkStridedBufferRegionKHR * pMissShaderBindingTable,const VkStridedBufferRegionKHR * pHitShaderBindingTable,const VkStridedBufferRegionKHR * pCallableShaderBindingTable,VkBuffer buffer,VkDeviceSize offset) const6179 bool ObjectLifetimes::PreCallValidateCmdTraceRaysIndirectKHR(
6180 VkCommandBuffer commandBuffer,
6181 const VkStridedBufferRegionKHR* pRaygenShaderBindingTable,
6182 const VkStridedBufferRegionKHR* pMissShaderBindingTable,
6183 const VkStridedBufferRegionKHR* pHitShaderBindingTable,
6184 const VkStridedBufferRegionKHR* pCallableShaderBindingTable,
6185 VkBuffer buffer,
6186 VkDeviceSize offset) const {
6187 bool skip = false;
6188 skip |= ValidateObject(commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-parameter", "VUID-vkCmdTraceRaysIndirectKHR-commonparent");
6189 if (pRaygenShaderBindingTable) {
6190 skip |= ValidateObject(pRaygenShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6191 }
6192 if (pMissShaderBindingTable) {
6193 skip |= ValidateObject(pMissShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6194 }
6195 if (pHitShaderBindingTable) {
6196 skip |= ValidateObject(pHitShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6197 }
6198 if (pCallableShaderBindingTable) {
6199 skip |= ValidateObject(pCallableShaderBindingTable->buffer, kVulkanObjectTypeBuffer, true, "VUID-VkStridedBufferRegionKHR-buffer-parameter", kVUIDUndefined);
6200 }
6201 skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdTraceRaysIndirectKHR-buffer-parameter", "VUID-vkCmdTraceRaysIndirectKHR-commonparent");
6202
6203 return skip;
6204 }
6205 #endif // VK_ENABLE_BETA_EXTENSIONS
6206
6207 #ifdef VK_ENABLE_BETA_EXTENSIONS
6208
PreCallValidateGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device,const VkAccelerationStructureVersionKHR * version) const6209 bool ObjectLifetimes::PreCallValidateGetDeviceAccelerationStructureCompatibilityKHR(
6210 VkDevice device,
6211 const VkAccelerationStructureVersionKHR* version) const {
6212 bool skip = false;
6213 skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceAccelerationStructureCompatibilityKHR-device-parameter", kVUIDUndefined);
6214
6215 return skip;
6216 }
6217 #endif // VK_ENABLE_BETA_EXTENSIONS
6218
6219
6220