Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / b836ac94fee5d423f724d327f39538912ed5a75a / . / layers / generated / chassis.h
blob: 0a5eeaa18a2b9755527651b99e94eafef4235391 [file] [log] [blame]
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]1
2// This file is ***GENERATED***. Do Not Edit.
3// See layer_chassis_generator.py for modifications.
4
5/* Copyright (c) 2015-2019 The Khronos Group Inc.
6 * Copyright (c) 2015-2019 Valve Corporation
7 * Copyright (c) 2015-2019 LunarG, Inc.
8 * Copyright (c) 2015-2019 Google Inc.
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 *
22 * Author: Mark Lobodzinski <mark@lunarg.com>
23 */
24#pragma once
25
26
27#define NOMINMAX
28#include <mutex>
29#include <cinttypes>
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33#include <unordered_map>
34#include <unordered_set>
35#include <algorithm>
36#include <memory>
37
38#include "vk_loader_platform.h"
39#include "vulkan/vulkan.h"
40#include "vk_layer_config.h"
41#include "vk_layer_data.h"
42#include "vk_layer_logging.h"
43#include "vk_object_types.h"
44#include "vulkan/vk_layer.h"
45#include "vk_enum_string_helper.h"
46#include "vk_layer_extension_utils.h"
47#include "vk_layer_utils.h"
48#include "vulkan/vk_layer.h"
49#include "vk_dispatch_table_helper.h"
50#include "vk_extension_helper.h"
51#include "vk_safe_struct.h"
52#include "vk_typemap_helper.h"
53
54
55extern uint64_t global_unique_id;
56extern std::unordered_map<uint64_t, uint64_t> unique_id_mapping;
57
58
59
60VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
61 const VkInstanceCreateInfo* pCreateInfo,
62 const VkAllocationCallbacks* pAllocator,
63 VkInstance* pInstance);
64
65VKAPI_ATTR void VKAPI_CALL DestroyInstance(
66 VkInstance instance,
67 const VkAllocationCallbacks* pAllocator);
68
69VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
70 VkInstance instance,
71 uint32_t* pPhysicalDeviceCount,
72 VkPhysicalDevice* pPhysicalDevices);
73
74VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
75 VkPhysicalDevice physicalDevice,
76 VkPhysicalDeviceFeatures* pFeatures);
77
78VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
79 VkPhysicalDevice physicalDevice,
80 VkFormat format,
81 VkFormatProperties* pFormatProperties);
82
83VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
84 VkPhysicalDevice physicalDevice,
85 VkFormat format,
86 VkImageType type,
87 VkImageTiling tiling,
88 VkImageUsageFlags usage,
89 VkImageCreateFlags flags,
90 VkImageFormatProperties* pImageFormatProperties);
91
92VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
93 VkPhysicalDevice physicalDevice,
94 VkPhysicalDeviceProperties* pProperties);
95
96VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
97 VkPhysicalDevice physicalDevice,
98 uint32_t* pQueueFamilyPropertyCount,
99 VkQueueFamilyProperties* pQueueFamilyProperties);
100
101VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
102 VkPhysicalDevice physicalDevice,
103 VkPhysicalDeviceMemoryProperties* pMemoryProperties);
104
105VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
106 VkInstance instance,
107 const char* pName);
108
109VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
110 VkDevice device,
111 const char* pName);
112
113VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
114 VkPhysicalDevice physicalDevice,
115 const VkDeviceCreateInfo* pCreateInfo,
116 const VkAllocationCallbacks* pAllocator,
117 VkDevice* pDevice);
118
119VKAPI_ATTR void VKAPI_CALL DestroyDevice(
120 VkDevice device,
121 const VkAllocationCallbacks* pAllocator);
122
123VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
124 const char* pLayerName,
125 uint32_t* pPropertyCount,
126 VkExtensionProperties* pProperties);
127
128VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
129 VkPhysicalDevice physicalDevice,
130 const char* pLayerName,
131 uint32_t* pPropertyCount,
132 VkExtensionProperties* pProperties);
133
134VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
135 uint32_t* pPropertyCount,
136 VkLayerProperties* pProperties);
137
138VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
139 VkPhysicalDevice physicalDevice,
140 uint32_t* pPropertyCount,
141 VkLayerProperties* pProperties);
142
143VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
144 VkDevice device,
145 uint32_t queueFamilyIndex,
146 uint32_t queueIndex,
147 VkQueue* pQueue);
148
149VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
150 VkQueue queue,
151 uint32_t submitCount,
152 const VkSubmitInfo* pSubmits,
153 VkFence fence);
154
155VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
156 VkQueue queue);
157
158VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
159 VkDevice device);
160
161VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
162 VkDevice device,
163 const VkMemoryAllocateInfo* pAllocateInfo,
164 const VkAllocationCallbacks* pAllocator,
165 VkDeviceMemory* pMemory);
166
167VKAPI_ATTR void VKAPI_CALL FreeMemory(
168 VkDevice device,
169 VkDeviceMemory memory,
170 const VkAllocationCallbacks* pAllocator);
171
172VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
173 VkDevice device,
174 VkDeviceMemory memory,
175 VkDeviceSize offset,
176 VkDeviceSize size,
177 VkMemoryMapFlags flags,
178 void** ppData);
179
180VKAPI_ATTR void VKAPI_CALL UnmapMemory(
181 VkDevice device,
182 VkDeviceMemory memory);
183
184VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
185 VkDevice device,
186 uint32_t memoryRangeCount,
187 const VkMappedMemoryRange* pMemoryRanges);
188
189VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
190 VkDevice device,
191 uint32_t memoryRangeCount,
192 const VkMappedMemoryRange* pMemoryRanges);
193
194VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
195 VkDevice device,
196 VkDeviceMemory memory,
197 VkDeviceSize* pCommittedMemoryInBytes);
198
199VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
200 VkDevice device,
201 VkBuffer buffer,
202 VkDeviceMemory memory,
203 VkDeviceSize memoryOffset);
204
205VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
206 VkDevice device,
207 VkImage image,
208 VkDeviceMemory memory,
209 VkDeviceSize memoryOffset);
210
211VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
212 VkDevice device,
213 VkBuffer buffer,
214 VkMemoryRequirements* pMemoryRequirements);
215
216VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
217 VkDevice device,
218 VkImage image,
219 VkMemoryRequirements* pMemoryRequirements);
220
221VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
222 VkDevice device,
223 VkImage image,
224 uint32_t* pSparseMemoryRequirementCount,
225 VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
226
227VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
228 VkPhysicalDevice physicalDevice,
229 VkFormat format,
230 VkImageType type,
231 VkSampleCountFlagBits samples,
232 VkImageUsageFlags usage,
233 VkImageTiling tiling,
234 uint32_t* pPropertyCount,
235 VkSparseImageFormatProperties* pProperties);
236
237VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
238 VkQueue queue,
239 uint32_t bindInfoCount,
240 const VkBindSparseInfo* pBindInfo,
241 VkFence fence);
242
243VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
244 VkDevice device,
245 const VkFenceCreateInfo* pCreateInfo,
246 const VkAllocationCallbacks* pAllocator,
247 VkFence* pFence);
248
249VKAPI_ATTR void VKAPI_CALL DestroyFence(
250 VkDevice device,
251 VkFence fence,
252 const VkAllocationCallbacks* pAllocator);
253
254VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
255 VkDevice device,
256 uint32_t fenceCount,
257 const VkFence* pFences);
258
259VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
260 VkDevice device,
261 VkFence fence);
262
263VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
264 VkDevice device,
265 uint32_t fenceCount,
266 const VkFence* pFences,
267 VkBool32 waitAll,
268 uint64_t timeout);
269
270VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
271 VkDevice device,
272 const VkSemaphoreCreateInfo* pCreateInfo,
273 const VkAllocationCallbacks* pAllocator,
274 VkSemaphore* pSemaphore);
275
276VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
277 VkDevice device,
278 VkSemaphore semaphore,
279 const VkAllocationCallbacks* pAllocator);
280
281VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
282 VkDevice device,
283 const VkEventCreateInfo* pCreateInfo,
284 const VkAllocationCallbacks* pAllocator,
285 VkEvent* pEvent);
286
287VKAPI_ATTR void VKAPI_CALL DestroyEvent(
288 VkDevice device,
289 VkEvent event,
290 const VkAllocationCallbacks* pAllocator);
291
292VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
293 VkDevice device,
294 VkEvent event);
295
296VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
297 VkDevice device,
298 VkEvent event);
299
300VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
301 VkDevice device,
302 VkEvent event);
303
304VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
305 VkDevice device,
306 const VkQueryPoolCreateInfo* pCreateInfo,
307 const VkAllocationCallbacks* pAllocator,
308 VkQueryPool* pQueryPool);
309
310VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
311 VkDevice device,
312 VkQueryPool queryPool,
313 const VkAllocationCallbacks* pAllocator);
314
315VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
316 VkDevice device,
317 VkQueryPool queryPool,
318 uint32_t firstQuery,
319 uint32_t queryCount,
320 size_t dataSize,
321 void* pData,
322 VkDeviceSize stride,
323 VkQueryResultFlags flags);
324
325VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
326 VkDevice device,
327 const VkBufferCreateInfo* pCreateInfo,
328 const VkAllocationCallbacks* pAllocator,
329 VkBuffer* pBuffer);
330
331VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
332 VkDevice device,
333 VkBuffer buffer,
334 const VkAllocationCallbacks* pAllocator);
335
336VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
337 VkDevice device,
338 const VkBufferViewCreateInfo* pCreateInfo,
339 const VkAllocationCallbacks* pAllocator,
340 VkBufferView* pView);
341
342VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
343 VkDevice device,
344 VkBufferView bufferView,
345 const VkAllocationCallbacks* pAllocator);
346
347VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
348 VkDevice device,
349 const VkImageCreateInfo* pCreateInfo,
350 const VkAllocationCallbacks* pAllocator,
351 VkImage* pImage);
352
353VKAPI_ATTR void VKAPI_CALL DestroyImage(
354 VkDevice device,
355 VkImage image,
356 const VkAllocationCallbacks* pAllocator);
357
358VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
359 VkDevice device,
360 VkImage image,
361 const VkImageSubresource* pSubresource,
362 VkSubresourceLayout* pLayout);
363
364VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
365 VkDevice device,
366 const VkImageViewCreateInfo* pCreateInfo,
367 const VkAllocationCallbacks* pAllocator,
368 VkImageView* pView);
369
370VKAPI_ATTR void VKAPI_CALL DestroyImageView(
371 VkDevice device,
372 VkImageView imageView,
373 const VkAllocationCallbacks* pAllocator);
374
375VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
376 VkDevice device,
377 const VkShaderModuleCreateInfo* pCreateInfo,
378 const VkAllocationCallbacks* pAllocator,
379 VkShaderModule* pShaderModule);
380
381VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
382 VkDevice device,
383 VkShaderModule shaderModule,
384 const VkAllocationCallbacks* pAllocator);
385
386VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
387 VkDevice device,
388 const VkPipelineCacheCreateInfo* pCreateInfo,
389 const VkAllocationCallbacks* pAllocator,
390 VkPipelineCache* pPipelineCache);
391
392VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
393 VkDevice device,
394 VkPipelineCache pipelineCache,
395 const VkAllocationCallbacks* pAllocator);
396
397VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
398 VkDevice device,
399 VkPipelineCache pipelineCache,
400 size_t* pDataSize,
401 void* pData);
402
403VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
404 VkDevice device,
405 VkPipelineCache dstCache,
406 uint32_t srcCacheCount,
407 const VkPipelineCache* pSrcCaches);
408
409VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
410 VkDevice device,
411 VkPipelineCache pipelineCache,
412 uint32_t createInfoCount,
413 const VkGraphicsPipelineCreateInfo* pCreateInfos,
414 const VkAllocationCallbacks* pAllocator,
415 VkPipeline* pPipelines);
416
417VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
418 VkDevice device,
419 VkPipelineCache pipelineCache,
420 uint32_t createInfoCount,
421 const VkComputePipelineCreateInfo* pCreateInfos,
422 const VkAllocationCallbacks* pAllocator,
423 VkPipeline* pPipelines);
424
425VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
426 VkDevice device,
427 VkPipeline pipeline,
428 const VkAllocationCallbacks* pAllocator);
429
430VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
431 VkDevice device,
432 const VkPipelineLayoutCreateInfo* pCreateInfo,
433 const VkAllocationCallbacks* pAllocator,
434 VkPipelineLayout* pPipelineLayout);
435
436VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
437 VkDevice device,
438 VkPipelineLayout pipelineLayout,
439 const VkAllocationCallbacks* pAllocator);
440
441VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
442 VkDevice device,
443 const VkSamplerCreateInfo* pCreateInfo,
444 const VkAllocationCallbacks* pAllocator,
445 VkSampler* pSampler);
446
447VKAPI_ATTR void VKAPI_CALL DestroySampler(
448 VkDevice device,
449 VkSampler sampler,
450 const VkAllocationCallbacks* pAllocator);
451
452VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
453 VkDevice device,
454 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
455 const VkAllocationCallbacks* pAllocator,
456 VkDescriptorSetLayout* pSetLayout);
457
458VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
459 VkDevice device,
460 VkDescriptorSetLayout descriptorSetLayout,
461 const VkAllocationCallbacks* pAllocator);
462
463VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
464 VkDevice device,
465 const VkDescriptorPoolCreateInfo* pCreateInfo,
466 const VkAllocationCallbacks* pAllocator,
467 VkDescriptorPool* pDescriptorPool);
468
469VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
470 VkDevice device,
471 VkDescriptorPool descriptorPool,
472 const VkAllocationCallbacks* pAllocator);
473
474VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
475 VkDevice device,
476 VkDescriptorPool descriptorPool,
477 VkDescriptorPoolResetFlags flags);
478
479VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
480 VkDevice device,
481 const VkDescriptorSetAllocateInfo* pAllocateInfo,
482 VkDescriptorSet* pDescriptorSets);
483
484VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
485 VkDevice device,
486 VkDescriptorPool descriptorPool,
487 uint32_t descriptorSetCount,
488 const VkDescriptorSet* pDescriptorSets);
489
490VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
491 VkDevice device,
492 uint32_t descriptorWriteCount,
493 const VkWriteDescriptorSet* pDescriptorWrites,
494 uint32_t descriptorCopyCount,
495 const VkCopyDescriptorSet* pDescriptorCopies);
496
497VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
498 VkDevice device,
499 const VkFramebufferCreateInfo* pCreateInfo,
500 const VkAllocationCallbacks* pAllocator,
501 VkFramebuffer* pFramebuffer);
502
503VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
504 VkDevice device,
505 VkFramebuffer framebuffer,
506 const VkAllocationCallbacks* pAllocator);
507
508VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
509 VkDevice device,
510 const VkRenderPassCreateInfo* pCreateInfo,
511 const VkAllocationCallbacks* pAllocator,
512 VkRenderPass* pRenderPass);
513
514VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
515 VkDevice device,
516 VkRenderPass renderPass,
517 const VkAllocationCallbacks* pAllocator);
518
519VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
520 VkDevice device,
521 VkRenderPass renderPass,
522 VkExtent2D* pGranularity);
523
524VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
525 VkDevice device,
526 const VkCommandPoolCreateInfo* pCreateInfo,
527 const VkAllocationCallbacks* pAllocator,
528 VkCommandPool* pCommandPool);
529
530VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
531 VkDevice device,
532 VkCommandPool commandPool,
533 const VkAllocationCallbacks* pAllocator);
534
535VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
536 VkDevice device,
537 VkCommandPool commandPool,
538 VkCommandPoolResetFlags flags);
539
540VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
541 VkDevice device,
542 const VkCommandBufferAllocateInfo* pAllocateInfo,
543 VkCommandBuffer* pCommandBuffers);
544
545VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
546 VkDevice device,
547 VkCommandPool commandPool,
548 uint32_t commandBufferCount,
549 const VkCommandBuffer* pCommandBuffers);
550
551VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
552 VkCommandBuffer commandBuffer,
553 const VkCommandBufferBeginInfo* pBeginInfo);
554
555VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
556 VkCommandBuffer commandBuffer);
557
558VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
559 VkCommandBuffer commandBuffer,
560 VkCommandBufferResetFlags flags);
561
562VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
563 VkCommandBuffer commandBuffer,
564 VkPipelineBindPoint pipelineBindPoint,
565 VkPipeline pipeline);
566
567VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
568 VkCommandBuffer commandBuffer,
569 uint32_t firstViewport,
570 uint32_t viewportCount,
571 const VkViewport* pViewports);
572
573VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
574 VkCommandBuffer commandBuffer,
575 uint32_t firstScissor,
576 uint32_t scissorCount,
577 const VkRect2D* pScissors);
578
579VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
580 VkCommandBuffer commandBuffer,
581 float lineWidth);
582
583VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
584 VkCommandBuffer commandBuffer,
585 float depthBiasConstantFactor,
586 float depthBiasClamp,
587 float depthBiasSlopeFactor);
588
589VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
590 VkCommandBuffer commandBuffer,
591 const float blendConstants[4]);
592
593VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
594 VkCommandBuffer commandBuffer,
595 float minDepthBounds,
596 float maxDepthBounds);
597
598VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
599 VkCommandBuffer commandBuffer,
600 VkStencilFaceFlags faceMask,
601 uint32_t compareMask);
602
603VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
604 VkCommandBuffer commandBuffer,
605 VkStencilFaceFlags faceMask,
606 uint32_t writeMask);
607
608VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
609 VkCommandBuffer commandBuffer,
610 VkStencilFaceFlags faceMask,
611 uint32_t reference);
612
613VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
614 VkCommandBuffer commandBuffer,
615 VkPipelineBindPoint pipelineBindPoint,
616 VkPipelineLayout layout,
617 uint32_t firstSet,
618 uint32_t descriptorSetCount,
619 const VkDescriptorSet* pDescriptorSets,
620 uint32_t dynamicOffsetCount,
621 const uint32_t* pDynamicOffsets);
622
623VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
624 VkCommandBuffer commandBuffer,
625 VkBuffer buffer,
626 VkDeviceSize offset,
627 VkIndexType indexType);
628
629VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
630 VkCommandBuffer commandBuffer,
631 uint32_t firstBinding,
632 uint32_t bindingCount,
633 const VkBuffer* pBuffers,
634 const VkDeviceSize* pOffsets);
635
636VKAPI_ATTR void VKAPI_CALL CmdDraw(
637 VkCommandBuffer commandBuffer,
638 uint32_t vertexCount,
639 uint32_t instanceCount,
640 uint32_t firstVertex,
641 uint32_t firstInstance);
642
643VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
644 VkCommandBuffer commandBuffer,
645 uint32_t indexCount,
646 uint32_t instanceCount,
647 uint32_t firstIndex,
648 int32_t vertexOffset,
649 uint32_t firstInstance);
650
651VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
652 VkCommandBuffer commandBuffer,
653 VkBuffer buffer,
654 VkDeviceSize offset,
655 uint32_t drawCount,
656 uint32_t stride);
657
658VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
659 VkCommandBuffer commandBuffer,
660 VkBuffer buffer,
661 VkDeviceSize offset,
662 uint32_t drawCount,
663 uint32_t stride);
664
665VKAPI_ATTR void VKAPI_CALL CmdDispatch(
666 VkCommandBuffer commandBuffer,
667 uint32_t groupCountX,
668 uint32_t groupCountY,
669 uint32_t groupCountZ);
670
671VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
672 VkCommandBuffer commandBuffer,
673 VkBuffer buffer,
674 VkDeviceSize offset);
675
676VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
677 VkCommandBuffer commandBuffer,
678 VkBuffer srcBuffer,
679 VkBuffer dstBuffer,
680 uint32_t regionCount,
681 const VkBufferCopy* pRegions);
682
683VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
684 VkCommandBuffer commandBuffer,
685 VkImage srcImage,
686 VkImageLayout srcImageLayout,
687 VkImage dstImage,
688 VkImageLayout dstImageLayout,
689 uint32_t regionCount,
690 const VkImageCopy* pRegions);
691
692VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
693 VkCommandBuffer commandBuffer,
694 VkImage srcImage,
695 VkImageLayout srcImageLayout,
696 VkImage dstImage,
697 VkImageLayout dstImageLayout,
698 uint32_t regionCount,
699 const VkImageBlit* pRegions,
700 VkFilter filter);
701
702VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
703 VkCommandBuffer commandBuffer,
704 VkBuffer srcBuffer,
705 VkImage dstImage,
706 VkImageLayout dstImageLayout,
707 uint32_t regionCount,
708 const VkBufferImageCopy* pRegions);
709
710VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
711 VkCommandBuffer commandBuffer,
712 VkImage srcImage,
713 VkImageLayout srcImageLayout,
714 VkBuffer dstBuffer,
715 uint32_t regionCount,
716 const VkBufferImageCopy* pRegions);
717
718VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
719 VkCommandBuffer commandBuffer,
720 VkBuffer dstBuffer,
721 VkDeviceSize dstOffset,
722 VkDeviceSize dataSize,
723 const void* pData);
724
725VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
726 VkCommandBuffer commandBuffer,
727 VkBuffer dstBuffer,
728 VkDeviceSize dstOffset,
729 VkDeviceSize size,
730 uint32_t data);
731
732VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
733 VkCommandBuffer commandBuffer,
734 VkImage image,
735 VkImageLayout imageLayout,
736 const VkClearColorValue* pColor,
737 uint32_t rangeCount,
738 const VkImageSubresourceRange* pRanges);
739
740VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
741 VkCommandBuffer commandBuffer,
742 VkImage image,
743 VkImageLayout imageLayout,
744 const VkClearDepthStencilValue* pDepthStencil,
745 uint32_t rangeCount,
746 const VkImageSubresourceRange* pRanges);
747
748VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
749 VkCommandBuffer commandBuffer,
750 uint32_t attachmentCount,
751 const VkClearAttachment* pAttachments,
752 uint32_t rectCount,
753 const VkClearRect* pRects);
754
755VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
756 VkCommandBuffer commandBuffer,
757 VkImage srcImage,
758 VkImageLayout srcImageLayout,
759 VkImage dstImage,
760 VkImageLayout dstImageLayout,
761 uint32_t regionCount,
762 const VkImageResolve* pRegions);
763
764VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
765 VkCommandBuffer commandBuffer,
766 VkEvent event,
767 VkPipelineStageFlags stageMask);
768
769VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
770 VkCommandBuffer commandBuffer,
771 VkEvent event,
772 VkPipelineStageFlags stageMask);
773
774VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
775 VkCommandBuffer commandBuffer,
776 uint32_t eventCount,
777 const VkEvent* pEvents,
778 VkPipelineStageFlags srcStageMask,
779 VkPipelineStageFlags dstStageMask,
780 uint32_t memoryBarrierCount,
781 const VkMemoryBarrier* pMemoryBarriers,
782 uint32_t bufferMemoryBarrierCount,
783 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
784 uint32_t imageMemoryBarrierCount,
785 const VkImageMemoryBarrier* pImageMemoryBarriers);
786
787VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
788 VkCommandBuffer commandBuffer,
789 VkPipelineStageFlags srcStageMask,
790 VkPipelineStageFlags dstStageMask,
791 VkDependencyFlags dependencyFlags,
792 uint32_t memoryBarrierCount,
793 const VkMemoryBarrier* pMemoryBarriers,
794 uint32_t bufferMemoryBarrierCount,
795 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
796 uint32_t imageMemoryBarrierCount,
797 const VkImageMemoryBarrier* pImageMemoryBarriers);
798
799VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
800 VkCommandBuffer commandBuffer,
801 VkQueryPool queryPool,
802 uint32_t query,
803 VkQueryControlFlags flags);
804
805VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
806 VkCommandBuffer commandBuffer,
807 VkQueryPool queryPool,
808 uint32_t query);
809
810VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
811 VkCommandBuffer commandBuffer,
812 VkQueryPool queryPool,
813 uint32_t firstQuery,
814 uint32_t queryCount);
815
816VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
817 VkCommandBuffer commandBuffer,
818 VkPipelineStageFlagBits pipelineStage,
819 VkQueryPool queryPool,
820 uint32_t query);
821
822VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
823 VkCommandBuffer commandBuffer,
824 VkQueryPool queryPool,
825 uint32_t firstQuery,
826 uint32_t queryCount,
827 VkBuffer dstBuffer,
828 VkDeviceSize dstOffset,
829 VkDeviceSize stride,
830 VkQueryResultFlags flags);
831
832VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
833 VkCommandBuffer commandBuffer,
834 VkPipelineLayout layout,
835 VkShaderStageFlags stageFlags,
836 uint32_t offset,
837 uint32_t size,
838 const void* pValues);
839
840VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
841 VkCommandBuffer commandBuffer,
842 const VkRenderPassBeginInfo* pRenderPassBegin,
843 VkSubpassContents contents);
844
845VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
846 VkCommandBuffer commandBuffer,
847 VkSubpassContents contents);
848
849VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
850 VkCommandBuffer commandBuffer);
851
852VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
853 VkCommandBuffer commandBuffer,
854 uint32_t commandBufferCount,
855 const VkCommandBuffer* pCommandBuffers);
856
857
858VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
859 VkDevice device,
860 uint32_t bindInfoCount,
861 const VkBindBufferMemoryInfo* pBindInfos);
862
863VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
864 VkDevice device,
865 uint32_t bindInfoCount,
866 const VkBindImageMemoryInfo* pBindInfos);
867
868VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(
869 VkDevice device,
870 uint32_t heapIndex,
871 uint32_t localDeviceIndex,
872 uint32_t remoteDeviceIndex,
873 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
874
875VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(
876 VkCommandBuffer commandBuffer,
877 uint32_t deviceMask);
878
879VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(
880 VkCommandBuffer commandBuffer,
881 uint32_t baseGroupX,
882 uint32_t baseGroupY,
883 uint32_t baseGroupZ,
884 uint32_t groupCountX,
885 uint32_t groupCountY,
886 uint32_t groupCountZ);
887
888VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
889 VkInstance instance,
890 uint32_t* pPhysicalDeviceGroupCount,
891 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
892
893VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(
894 VkDevice device,
895 const VkImageMemoryRequirementsInfo2* pInfo,
896 VkMemoryRequirements2* pMemoryRequirements);
897
898VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(
899 VkDevice device,
900 const VkBufferMemoryRequirementsInfo2* pInfo,
901 VkMemoryRequirements2* pMemoryRequirements);
902
903VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
904 VkDevice device,
905 const VkImageSparseMemoryRequirementsInfo2* pInfo,
906 uint32_t* pSparseMemoryRequirementCount,
907 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
908
909VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(
910 VkPhysicalDevice physicalDevice,
911 VkPhysicalDeviceFeatures2* pFeatures);
912
913VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(
914 VkPhysicalDevice physicalDevice,
915 VkPhysicalDeviceProperties2* pProperties);
916
917VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(
918 VkPhysicalDevice physicalDevice,
919 VkFormat format,
920 VkFormatProperties2* pFormatProperties);
921
922VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
923 VkPhysicalDevice physicalDevice,
924 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
925 VkImageFormatProperties2* pImageFormatProperties);
926
927VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(
928 VkPhysicalDevice physicalDevice,
929 uint32_t* pQueueFamilyPropertyCount,
930 VkQueueFamilyProperties2* pQueueFamilyProperties);
931
932VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(
933 VkPhysicalDevice physicalDevice,
934 VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
935
936VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
937 VkPhysicalDevice physicalDevice,
938 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
939 uint32_t* pPropertyCount,
940 VkSparseImageFormatProperties2* pProperties);
941
942VKAPI_ATTR void VKAPI_CALL TrimCommandPool(
943 VkDevice device,
944 VkCommandPool commandPool,
945 VkCommandPoolTrimFlags flags);
946
947VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(
948 VkDevice device,
949 const VkDeviceQueueInfo2* pQueueInfo,
950 VkQueue* pQueue);
951
952VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(
953 VkDevice device,
954 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
955 const VkAllocationCallbacks* pAllocator,
956 VkSamplerYcbcrConversion* pYcbcrConversion);
957
958VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(
959 VkDevice device,
960 VkSamplerYcbcrConversion ycbcrConversion,
961 const VkAllocationCallbacks* pAllocator);
962
963VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(
964 VkDevice device,
965 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
966 const VkAllocationCallbacks* pAllocator,
967 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
968
969VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(
970 VkDevice device,
971 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
972 const VkAllocationCallbacks* pAllocator);
973
974VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
975 VkDevice device,
976 VkDescriptorSet descriptorSet,
977 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
978 const void* pData);
979
980VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
981 VkPhysicalDevice physicalDevice,
982 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
983 VkExternalBufferProperties* pExternalBufferProperties);
984
985VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
986 VkPhysicalDevice physicalDevice,
987 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
988 VkExternalFenceProperties* pExternalFenceProperties);
989
990VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
991 VkPhysicalDevice physicalDevice,
992 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
993 VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
994
995VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(
996 VkDevice device,
997 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
998 VkDescriptorSetLayoutSupport* pSupport);
999
1000
1001VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
1002 VkInstance instance,
1003 VkSurfaceKHR surface,
1004 const VkAllocationCallbacks* pAllocator);
1005
1006VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
1007 VkPhysicalDevice physicalDevice,
1008 uint32_t queueFamilyIndex,
1009 VkSurfaceKHR surface,
1010 VkBool32* pSupported);
1011
1012VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
1013 VkPhysicalDevice physicalDevice,
1014 VkSurfaceKHR surface,
1015 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
1016
1017VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
1018 VkPhysicalDevice physicalDevice,
1019 VkSurfaceKHR surface,
1020 uint32_t* pSurfaceFormatCount,
1021 VkSurfaceFormatKHR* pSurfaceFormats);
1022
1023VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
1024 VkPhysicalDevice physicalDevice,
1025 VkSurfaceKHR surface,
1026 uint32_t* pPresentModeCount,
1027 VkPresentModeKHR* pPresentModes);
1028
1029
1030VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
1031 VkDevice device,
1032 const VkSwapchainCreateInfoKHR* pCreateInfo,
1033 const VkAllocationCallbacks* pAllocator,
1034 VkSwapchainKHR* pSwapchain);
1035
1036VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
1037 VkDevice device,
1038 VkSwapchainKHR swapchain,
1039 const VkAllocationCallbacks* pAllocator);
1040
1041VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
1042 VkDevice device,
1043 VkSwapchainKHR swapchain,
1044 uint32_t* pSwapchainImageCount,
1045 VkImage* pSwapchainImages);
1046
1047VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
1048 VkDevice device,
1049 VkSwapchainKHR swapchain,
1050 uint64_t timeout,
1051 VkSemaphore semaphore,
1052 VkFence fence,
1053 uint32_t* pImageIndex);
1054
1055VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
1056 VkQueue queue,
1057 const VkPresentInfoKHR* pPresentInfo);
1058
1059VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR(
1060 VkDevice device,
1061 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
1062
1063VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(
1064 VkDevice device,
1065 VkSurfaceKHR surface,
1066 VkDeviceGroupPresentModeFlagsKHR* pModes);
1067
1068VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(
1069 VkPhysicalDevice physicalDevice,
1070 VkSurfaceKHR surface,
1071 uint32_t* pRectCount,
1072 VkRect2D* pRects);
1073
1074VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(
1075 VkDevice device,
1076 const VkAcquireNextImageInfoKHR* pAcquireInfo,
1077 uint32_t* pImageIndex);
1078
1079
1080VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
1081 VkPhysicalDevice physicalDevice,
1082 uint32_t* pPropertyCount,
1083 VkDisplayPropertiesKHR* pProperties);
1084
1085VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
1086 VkPhysicalDevice physicalDevice,
1087 uint32_t* pPropertyCount,
1088 VkDisplayPlanePropertiesKHR* pProperties);
1089
1090VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
1091 VkPhysicalDevice physicalDevice,
1092 uint32_t planeIndex,
1093 uint32_t* pDisplayCount,
1094 VkDisplayKHR* pDisplays);
1095
1096VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
1097 VkPhysicalDevice physicalDevice,
1098 VkDisplayKHR display,
1099 uint32_t* pPropertyCount,
1100 VkDisplayModePropertiesKHR* pProperties);
1101
1102VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
1103 VkPhysicalDevice physicalDevice,
1104 VkDisplayKHR display,
1105 const VkDisplayModeCreateInfoKHR* pCreateInfo,
1106 const VkAllocationCallbacks* pAllocator,
1107 VkDisplayModeKHR* pMode);
1108
1109VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
1110 VkPhysicalDevice physicalDevice,
1111 VkDisplayModeKHR mode,
1112 uint32_t planeIndex,
1113 VkDisplayPlaneCapabilitiesKHR* pCapabilities);
1114
1115VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
1116 VkInstance instance,
1117 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
1118 const VkAllocationCallbacks* pAllocator,
1119 VkSurfaceKHR* pSurface);
1120
1121
1122VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
1123 VkDevice device,
1124 uint32_t swapchainCount,
1125 const VkSwapchainCreateInfoKHR* pCreateInfos,
1126 const VkAllocationCallbacks* pAllocator,
1127 VkSwapchainKHR* pSwapchains);
1128
1129#ifdef VK_USE_PLATFORM_XLIB_KHR
1130
1131VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
1132 VkInstance instance,
1133 const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
1134 const VkAllocationCallbacks* pAllocator,
1135 VkSurfaceKHR* pSurface);
1136
1137VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
1138 VkPhysicalDevice physicalDevice,
1139 uint32_t queueFamilyIndex,
1140 Display* dpy,
1141 VisualID visualID);
1142#endif // VK_USE_PLATFORM_XLIB_KHR
1143
1144#ifdef VK_USE_PLATFORM_XCB_KHR
1145
1146VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
1147 VkInstance instance,
1148 const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
1149 const VkAllocationCallbacks* pAllocator,
1150 VkSurfaceKHR* pSurface);
1151
1152VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
1153 VkPhysicalDevice physicalDevice,
1154 uint32_t queueFamilyIndex,
1155 xcb_connection_t* connection,
1156 xcb_visualid_t visual_id);
1157#endif // VK_USE_PLATFORM_XCB_KHR
1158
1159#ifdef VK_USE_PLATFORM_WAYLAND_KHR
1160
1161VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
1162 VkInstance instance,
1163 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
1164 const VkAllocationCallbacks* pAllocator,
1165 VkSurfaceKHR* pSurface);
1166
1167VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
1168 VkPhysicalDevice physicalDevice,
1169 uint32_t queueFamilyIndex,
1170 struct wl_display* display);
1171#endif // VK_USE_PLATFORM_WAYLAND_KHR
1172
1173#ifdef VK_USE_PLATFORM_ANDROID_KHR
1174
1175VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
1176 VkInstance instance,
1177 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
1178 const VkAllocationCallbacks* pAllocator,
1179 VkSurfaceKHR* pSurface);
1180#endif // VK_USE_PLATFORM_ANDROID_KHR
1181
1182#ifdef VK_USE_PLATFORM_WIN32_KHR
1183
1184VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
1185 VkInstance instance,
1186 const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
1187 const VkAllocationCallbacks* pAllocator,
1188 VkSurfaceKHR* pSurface);
1189
1190VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
1191 VkPhysicalDevice physicalDevice,
1192 uint32_t queueFamilyIndex);
1193#endif // VK_USE_PLATFORM_WIN32_KHR
1194
1195
1196
1197
1198VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
1199 VkPhysicalDevice physicalDevice,
1200 VkPhysicalDeviceFeatures2* pFeatures);
1201
1202VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
1203 VkPhysicalDevice physicalDevice,
1204 VkPhysicalDeviceProperties2* pProperties);
1205
1206VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
1207 VkPhysicalDevice physicalDevice,
1208 VkFormat format,
1209 VkFormatProperties2* pFormatProperties);
1210
1211VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
1212 VkPhysicalDevice physicalDevice,
1213 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
1214 VkImageFormatProperties2* pImageFormatProperties);
1215
1216VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
1217 VkPhysicalDevice physicalDevice,
1218 uint32_t* pQueueFamilyPropertyCount,
1219 VkQueueFamilyProperties2* pQueueFamilyProperties);
1220
1221VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
1222 VkPhysicalDevice physicalDevice,
1223 VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
1224
1225VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
1226 VkPhysicalDevice physicalDevice,
1227 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1228 uint32_t* pPropertyCount,
1229 VkSparseImageFormatProperties2* pProperties);
1230
1231
1232VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(
1233 VkDevice device,
1234 uint32_t heapIndex,
1235 uint32_t localDeviceIndex,
1236 uint32_t remoteDeviceIndex,
1237 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
1238
1239VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(
1240 VkCommandBuffer commandBuffer,
1241 uint32_t deviceMask);
1242
1243VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(
1244 VkCommandBuffer commandBuffer,
1245 uint32_t baseGroupX,
1246 uint32_t baseGroupY,
1247 uint32_t baseGroupZ,
1248 uint32_t groupCountX,
1249 uint32_t groupCountY,
1250 uint32_t groupCountZ);
1251
1252
1253
1254VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
1255 VkDevice device,
1256 VkCommandPool commandPool,
1257 VkCommandPoolTrimFlags flags);
1258
1259
1260VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
1261 VkInstance instance,
1262 uint32_t* pPhysicalDeviceGroupCount,
1263 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
1264
1265
1266VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
1267 VkPhysicalDevice physicalDevice,
1268 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
1269 VkExternalBufferProperties* pExternalBufferProperties);
1270
1271
1272#ifdef VK_USE_PLATFORM_WIN32_KHR
1273
1274VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
1275 VkDevice device,
1276 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1277 HANDLE* pHandle);
1278
1279VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
1280 VkDevice device,
1281 VkExternalMemoryHandleTypeFlagBits handleType,
1282 HANDLE handle,
1283 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
1284#endif // VK_USE_PLATFORM_WIN32_KHR
1285
1286
1287VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
1288 VkDevice device,
1289 const VkMemoryGetFdInfoKHR* pGetFdInfo,
1290 int* pFd);
1291
1292VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
1293 VkDevice device,
1294 VkExternalMemoryHandleTypeFlagBits handleType,
1295 int fd,
1296 VkMemoryFdPropertiesKHR* pMemoryFdProperties);
1297
1298#ifdef VK_USE_PLATFORM_WIN32_KHR
1299#endif // VK_USE_PLATFORM_WIN32_KHR
1300
1301
1302VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
1303 VkPhysicalDevice physicalDevice,
1304 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1305 VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
1306
1307
1308#ifdef VK_USE_PLATFORM_WIN32_KHR
1309
1310VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
1311 VkDevice device,
1312 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
1313
1314VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
1315 VkDevice device,
1316 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1317 HANDLE* pHandle);
1318#endif // VK_USE_PLATFORM_WIN32_KHR
1319
1320
1321VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
1322 VkDevice device,
1323 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
1324
1325VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
1326 VkDevice device,
1327 const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
1328 int* pFd);
1329
1330
1331VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
1332 VkCommandBuffer commandBuffer,
1333 VkPipelineBindPoint pipelineBindPoint,
1334 VkPipelineLayout layout,
1335 uint32_t set,
1336 uint32_t descriptorWriteCount,
1337 const VkWriteDescriptorSet* pDescriptorWrites);
1338
1339VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
1340 VkCommandBuffer commandBuffer,
1341 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1342 VkPipelineLayout layout,
1343 uint32_t set,
1344 const void* pData);
1345
1346
1347
1348
1349
1350VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
1351 VkDevice device,
1352 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1353 const VkAllocationCallbacks* pAllocator,
1354 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
1355
1356VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
1357 VkDevice device,
1358 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1359 const VkAllocationCallbacks* pAllocator);
1360
1361VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
1362 VkDevice device,
1363 VkDescriptorSet descriptorSet,
1364 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1365 const void* pData);
1366
1367
Shannon McPherson0e65e192019-07-17 16:52:21 -0600[diff] [blame]1368
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]1369VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(
1370 VkDevice device,
1371 const VkRenderPassCreateInfo2KHR* pCreateInfo,
1372 const VkAllocationCallbacks* pAllocator,
1373 VkRenderPass* pRenderPass);
1374
1375VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
1376 VkCommandBuffer commandBuffer,
1377 const VkRenderPassBeginInfo* pRenderPassBegin,
1378 const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
1379
1380VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
1381 VkCommandBuffer commandBuffer,
1382 const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
1383 const VkSubpassEndInfoKHR* pSubpassEndInfo);
1384
1385VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
1386 VkCommandBuffer commandBuffer,
1387 const VkSubpassEndInfoKHR* pSubpassEndInfo);
1388
1389
1390VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
1391 VkDevice device,
1392 VkSwapchainKHR swapchain);
1393
1394
1395VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
1396 VkPhysicalDevice physicalDevice,
1397 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
1398 VkExternalFenceProperties* pExternalFenceProperties);
1399
1400
1401#ifdef VK_USE_PLATFORM_WIN32_KHR
1402
1403VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
1404 VkDevice device,
1405 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
1406
1407VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
1408 VkDevice device,
1409 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1410 HANDLE* pHandle);
1411#endif // VK_USE_PLATFORM_WIN32_KHR
1412
1413
1414VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
1415 VkDevice device,
1416 const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
1417
1418VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
1419 VkDevice device,
1420 const VkFenceGetFdInfoKHR* pGetFdInfo,
1421 int* pFd);
1422
1423
1424
1425VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
1426 VkPhysicalDevice physicalDevice,
1427 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1428 VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
1429
1430VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
1431 VkPhysicalDevice physicalDevice,
1432 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1433 uint32_t* pSurfaceFormatCount,
1434 VkSurfaceFormat2KHR* pSurfaceFormats);
1435
1436
1437
1438VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(
1439 VkPhysicalDevice physicalDevice,
1440 uint32_t* pPropertyCount,
1441 VkDisplayProperties2KHR* pProperties);
1442
1443VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(
1444 VkPhysicalDevice physicalDevice,
1445 uint32_t* pPropertyCount,
1446 VkDisplayPlaneProperties2KHR* pProperties);
1447
1448VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(
1449 VkPhysicalDevice physicalDevice,
1450 VkDisplayKHR display,
1451 uint32_t* pPropertyCount,
1452 VkDisplayModeProperties2KHR* pProperties);
1453
1454VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(
1455 VkPhysicalDevice physicalDevice,
1456 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
1457 VkDisplayPlaneCapabilities2KHR* pCapabilities);
1458
1459
1460
1461
1462
1463VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
1464 VkDevice device,
1465 const VkImageMemoryRequirementsInfo2* pInfo,
1466 VkMemoryRequirements2* pMemoryRequirements);
1467
1468VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
1469 VkDevice device,
1470 const VkBufferMemoryRequirementsInfo2* pInfo,
1471 VkMemoryRequirements2* pMemoryRequirements);
1472
1473VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
1474 VkDevice device,
1475 const VkImageSparseMemoryRequirementsInfo2* pInfo,
1476 uint32_t* pSparseMemoryRequirementCount,
1477 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
1478
1479
1480
1481VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
1482 VkDevice device,
1483 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
1484 const VkAllocationCallbacks* pAllocator,
1485 VkSamplerYcbcrConversion* pYcbcrConversion);
1486
1487VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
1488 VkDevice device,
1489 VkSamplerYcbcrConversion ycbcrConversion,
1490 const VkAllocationCallbacks* pAllocator);
1491
1492
1493VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
1494 VkDevice device,
1495 uint32_t bindInfoCount,
1496 const VkBindBufferMemoryInfo* pBindInfos);
1497
1498VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
1499 VkDevice device,
1500 uint32_t bindInfoCount,
1501 const VkBindImageMemoryInfo* pBindInfos);
1502
1503
1504VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(
1505 VkDevice device,
1506 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1507 VkDescriptorSetLayoutSupport* pSupport);
1508
1509
1510VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(
1511 VkCommandBuffer commandBuffer,
1512 VkBuffer buffer,
1513 VkDeviceSize offset,
1514 VkBuffer countBuffer,
1515 VkDeviceSize countBufferOffset,
1516 uint32_t maxDrawCount,
1517 uint32_t stride);
1518
1519VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
1520 VkCommandBuffer commandBuffer,
1521 VkBuffer buffer,
1522 VkDeviceSize offset,
1523 VkBuffer countBuffer,
1524 VkDeviceSize countBufferOffset,
1525 uint32_t maxDrawCount,
1526 uint32_t stride);
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
1539 VkInstance instance,
1540 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
1541 const VkAllocationCallbacks* pAllocator,
1542 VkDebugReportCallbackEXT* pCallback);
1543
1544VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
1545 VkInstance instance,
1546 VkDebugReportCallbackEXT callback,
1547 const VkAllocationCallbacks* pAllocator);
1548
1549VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
1550 VkInstance instance,
1551 VkDebugReportFlagsEXT flags,
1552 VkDebugReportObjectTypeEXT objectType,
1553 uint64_t object,
1554 size_t location,
1555 int32_t messageCode,
1556 const char* pLayerPrefix,
1557 const char* pMessage);
1558
1559
1560
1561
1562
1563
1564
1565
1566VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
1567 VkDevice device,
1568 const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
1569
1570VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
1571 VkDevice device,
1572 const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
1573
1574VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
1575 VkCommandBuffer commandBuffer,
1576 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
1577
1578VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
1579 VkCommandBuffer commandBuffer);
1580
1581VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
1582 VkCommandBuffer commandBuffer,
1583 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
1584
1585
1586
1587
1588VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
1589 VkCommandBuffer commandBuffer,
1590 uint32_t firstBinding,
1591 uint32_t bindingCount,
1592 const VkBuffer* pBuffers,
1593 const VkDeviceSize* pOffsets,
1594 const VkDeviceSize* pSizes);
1595
1596VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
1597 VkCommandBuffer commandBuffer,
1598 uint32_t firstCounterBuffer,
1599 uint32_t counterBufferCount,
1600 const VkBuffer* pCounterBuffers,
1601 const VkDeviceSize* pCounterBufferOffsets);
1602
1603VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
1604 VkCommandBuffer commandBuffer,
1605 uint32_t firstCounterBuffer,
1606 uint32_t counterBufferCount,
1607 const VkBuffer* pCounterBuffers,
1608 const VkDeviceSize* pCounterBufferOffsets);
1609
1610VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
1611 VkCommandBuffer commandBuffer,
1612 VkQueryPool queryPool,
1613 uint32_t query,
1614 VkQueryControlFlags flags,
1615 uint32_t index);
1616
1617VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
1618 VkCommandBuffer commandBuffer,
1619 VkQueryPool queryPool,
1620 uint32_t query,
1621 uint32_t index);
1622
1623VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
1624 VkCommandBuffer commandBuffer,
1625 uint32_t instanceCount,
1626 uint32_t firstInstance,
1627 VkBuffer counterBuffer,
1628 VkDeviceSize counterBufferOffset,
1629 uint32_t counterOffset,
1630 uint32_t vertexStride);
1631
1632
1633VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(
1634 VkDevice device,
1635 const VkImageViewHandleInfoNVX* pInfo);
1636
1637
1638VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
1639 VkCommandBuffer commandBuffer,
1640 VkBuffer buffer,
1641 VkDeviceSize offset,
1642 VkBuffer countBuffer,
1643 VkDeviceSize countBufferOffset,
1644 uint32_t maxDrawCount,
1645 uint32_t stride);
1646
1647VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
1648 VkCommandBuffer commandBuffer,
1649 VkBuffer buffer,
1650 VkDeviceSize offset,
1651 VkBuffer countBuffer,
1652 VkDeviceSize countBufferOffset,
1653 uint32_t maxDrawCount,
1654 uint32_t stride);
1655
1656
1657
1658
1659
1660
1661VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
1662 VkDevice device,
1663 VkPipeline pipeline,
1664 VkShaderStageFlagBits shaderStage,
1665 VkShaderInfoTypeAMD infoType,
1666 size_t* pInfoSize,
1667 void* pInfo);
1668
1669
1670#ifdef VK_USE_PLATFORM_GGP
1671
1672VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(
1673 VkInstance instance,
1674 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
1675 const VkAllocationCallbacks* pAllocator,
1676 VkSurfaceKHR* pSurface);
1677#endif // VK_USE_PLATFORM_GGP
1678
1679
1680
1681
1682VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
1683 VkPhysicalDevice physicalDevice,
1684 VkFormat format,
1685 VkImageType type,
1686 VkImageTiling tiling,
1687 VkImageUsageFlags usage,
1688 VkImageCreateFlags flags,
1689 VkExternalMemoryHandleTypeFlagsNV externalHandleType,
1690 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
1691
1692
1693#ifdef VK_USE_PLATFORM_WIN32_KHR
1694
1695VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
1696 VkDevice device,
1697 VkDeviceMemory memory,
1698 VkExternalMemoryHandleTypeFlagsNV handleType,
1699 HANDLE* pHandle);
1700#endif // VK_USE_PLATFORM_WIN32_KHR
1701
1702#ifdef VK_USE_PLATFORM_WIN32_KHR
1703#endif // VK_USE_PLATFORM_WIN32_KHR
1704
1705
1706#ifdef VK_USE_PLATFORM_VI_NN
1707
1708VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
1709 VkInstance instance,
1710 const VkViSurfaceCreateInfoNN* pCreateInfo,
1711 const VkAllocationCallbacks* pAllocator,
1712 VkSurfaceKHR* pSurface);
1713#endif // VK_USE_PLATFORM_VI_NN
1714
1715
1716
1717
1718
1719VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
1720 VkCommandBuffer commandBuffer,
1721 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
1722
1723VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(
1724 VkCommandBuffer commandBuffer);
1725
1726
1727VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(
1728 VkCommandBuffer commandBuffer,
1729 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
1730
1731VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(
1732 VkCommandBuffer commandBuffer,
1733 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
1734
1735VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(
1736 VkDevice device,
1737 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
1738 const VkAllocationCallbacks* pAllocator,
1739 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
1740
1741VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(
1742 VkDevice device,
1743 VkIndirectCommandsLayoutNVX indirectCommandsLayout,
1744 const VkAllocationCallbacks* pAllocator);
1745
1746VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(
1747 VkDevice device,
1748 const VkObjectTableCreateInfoNVX* pCreateInfo,
1749 const VkAllocationCallbacks* pAllocator,
1750 VkObjectTableNVX* pObjectTable);
1751
1752VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(
1753 VkDevice device,
1754 VkObjectTableNVX objectTable,
1755 const VkAllocationCallbacks* pAllocator);
1756
1757VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(
1758 VkDevice device,
1759 VkObjectTableNVX objectTable,
1760 uint32_t objectCount,
1761 const VkObjectTableEntryNVX* const* ppObjectTableEntries,
1762 const uint32_t* pObjectIndices);
1763
1764VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(
1765 VkDevice device,
1766 VkObjectTableNVX objectTable,
1767 uint32_t objectCount,
1768 const VkObjectEntryTypeNVX* pObjectEntryTypes,
1769 const uint32_t* pObjectIndices);
1770
1771VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
1772 VkPhysicalDevice physicalDevice,
1773 VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
1774 VkDeviceGeneratedCommandsLimitsNVX* pLimits);
1775
1776
1777VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
1778 VkCommandBuffer commandBuffer,
1779 uint32_t firstViewport,
1780 uint32_t viewportCount,
1781 const VkViewportWScalingNV* pViewportWScalings);
1782
1783
1784VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
1785 VkPhysicalDevice physicalDevice,
1786 VkDisplayKHR display);
1787
1788#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
1789
1790VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
1791 VkPhysicalDevice physicalDevice,
1792 Display* dpy,
1793 VkDisplayKHR display);
1794
1795VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
1796 VkPhysicalDevice physicalDevice,
1797 Display* dpy,
1798 RROutput rrOutput,
1799 VkDisplayKHR* pDisplay);
1800#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
1801
1802
1803VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
1804 VkPhysicalDevice physicalDevice,
1805 VkSurfaceKHR surface,
1806 VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
1807
1808
1809VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
1810 VkDevice device,
1811 VkDisplayKHR display,
1812 const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
1813
1814VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
1815 VkDevice device,
1816 const VkDeviceEventInfoEXT* pDeviceEventInfo,
1817 const VkAllocationCallbacks* pAllocator,
1818 VkFence* pFence);
1819
1820VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
1821 VkDevice device,
1822 VkDisplayKHR display,
1823 const VkDisplayEventInfoEXT* pDisplayEventInfo,
1824 const VkAllocationCallbacks* pAllocator,
1825 VkFence* pFence);
1826
1827VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
1828 VkDevice device,
1829 VkSwapchainKHR swapchain,
1830 VkSurfaceCounterFlagBitsEXT counter,
1831 uint64_t* pCounterValue);
1832
1833
1834VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
1835 VkDevice device,
1836 VkSwapchainKHR swapchain,
1837 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
1838
1839VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
1840 VkDevice device,
1841 VkSwapchainKHR swapchain,
1842 uint32_t* pPresentationTimingCount,
1843 VkPastPresentationTimingGOOGLE* pPresentationTimings);
1844
1845
1846
1847
1848
1849
1850
1851VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
1852 VkCommandBuffer commandBuffer,
1853 uint32_t firstDiscardRectangle,
1854 uint32_t discardRectangleCount,
1855 const VkRect2D* pDiscardRectangles);
1856
1857
1858
1859
1860
1861VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
1862 VkDevice device,
1863 uint32_t swapchainCount,
1864 const VkSwapchainKHR* pSwapchains,
1865 const VkHdrMetadataEXT* pMetadata);
1866
1867#ifdef VK_USE_PLATFORM_IOS_MVK
1868
1869VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
1870 VkInstance instance,
1871 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
1872 const VkAllocationCallbacks* pAllocator,
1873 VkSurfaceKHR* pSurface);
1874#endif // VK_USE_PLATFORM_IOS_MVK
1875
1876#ifdef VK_USE_PLATFORM_MACOS_MVK
1877
1878VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
1879 VkInstance instance,
1880 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
1881 const VkAllocationCallbacks* pAllocator,
1882 VkSurfaceKHR* pSurface);
1883#endif // VK_USE_PLATFORM_MACOS_MVK
1884
1885
1886
1887
1888VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(
1889 VkDevice device,
1890 const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
1891
1892VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(
1893 VkDevice device,
1894 const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
1895
1896VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(
1897 VkQueue queue,
1898 const VkDebugUtilsLabelEXT* pLabelInfo);
1899
1900VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(
1901 VkQueue queue);
1902
1903VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(
1904 VkQueue queue,
1905 const VkDebugUtilsLabelEXT* pLabelInfo);
1906
1907VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(
1908 VkCommandBuffer commandBuffer,
1909 const VkDebugUtilsLabelEXT* pLabelInfo);
1910
1911VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(
1912 VkCommandBuffer commandBuffer);
1913
1914VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(
1915 VkCommandBuffer commandBuffer,
1916 const VkDebugUtilsLabelEXT* pLabelInfo);
1917
1918VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(
1919 VkInstance instance,
1920 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
1921 const VkAllocationCallbacks* pAllocator,
1922 VkDebugUtilsMessengerEXT* pMessenger);
1923
1924VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(
1925 VkInstance instance,
1926 VkDebugUtilsMessengerEXT messenger,
1927 const VkAllocationCallbacks* pAllocator);
1928
1929VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(
1930 VkInstance instance,
1931 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
1932 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
1933 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
1934
1935#ifdef VK_USE_PLATFORM_ANDROID_KHR
1936
1937VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
1938 VkDevice device,
1939 const struct AHardwareBuffer* buffer,
1940 VkAndroidHardwareBufferPropertiesANDROID* pProperties);
1941
1942VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
1943 VkDevice device,
1944 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
1945 struct AHardwareBuffer** pBuffer);
1946#endif // VK_USE_PLATFORM_ANDROID_KHR
1947
1948
1949
1950
1951
1952
1953
1954
1955VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
1956 VkCommandBuffer commandBuffer,
1957 const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
1958
1959VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
1960 VkPhysicalDevice physicalDevice,
1961 VkSampleCountFlagBits samples,
1962 VkMultisamplePropertiesEXT* pMultisampleProperties);
1963
1964
1965
1966
1967
1968
1969
1970
1971VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
1972 VkDevice device,
1973 VkImage image,
1974 VkImageDrmFormatModifierPropertiesEXT* pProperties);
1975
1976
1977VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
1978 VkDevice device,
1979 const VkValidationCacheCreateInfoEXT* pCreateInfo,
1980 const VkAllocationCallbacks* pAllocator,
1981 VkValidationCacheEXT* pValidationCache);
1982
1983VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
1984 VkDevice device,
1985 VkValidationCacheEXT validationCache,
1986 const VkAllocationCallbacks* pAllocator);
1987
1988VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
1989 VkDevice device,
1990 VkValidationCacheEXT dstCache,
1991 uint32_t srcCacheCount,
1992 const VkValidationCacheEXT* pSrcCaches);
1993
1994VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
1995 VkDevice device,
1996 VkValidationCacheEXT validationCache,
1997 size_t* pDataSize,
1998 void* pData);
1999
2000
2001
2002
2003VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(
2004 VkCommandBuffer commandBuffer,
2005 VkImageView imageView,
2006 VkImageLayout imageLayout);
2007
2008VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(
2009 VkCommandBuffer commandBuffer,
2010 uint32_t firstViewport,
2011 uint32_t viewportCount,
2012 const VkShadingRatePaletteNV* pShadingRatePalettes);
2013
2014VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(
2015 VkCommandBuffer commandBuffer,
2016 VkCoarseSampleOrderTypeNV sampleOrderType,
2017 uint32_t customSampleOrderCount,
2018 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
2019
2020
2021VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(
2022 VkDevice device,
2023 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
2024 const VkAllocationCallbacks* pAllocator,
2025 VkAccelerationStructureNV* pAccelerationStructure);
2026
2027VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(
2028 VkDevice device,
2029 VkAccelerationStructureNV accelerationStructure,
2030 const VkAllocationCallbacks* pAllocator);
2031
2032VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
2033 VkDevice device,
2034 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
2035 VkMemoryRequirements2KHR* pMemoryRequirements);
2036
2037VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(
2038 VkDevice device,
2039 uint32_t bindInfoCount,
2040 const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
2041
2042VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(
2043 VkCommandBuffer commandBuffer,
2044 const VkAccelerationStructureInfoNV* pInfo,
2045 VkBuffer instanceData,
2046 VkDeviceSize instanceOffset,
2047 VkBool32 update,
2048 VkAccelerationStructureNV dst,
2049 VkAccelerationStructureNV src,
2050 VkBuffer scratch,
2051 VkDeviceSize scratchOffset);
2052
2053VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(
2054 VkCommandBuffer commandBuffer,
2055 VkAccelerationStructureNV dst,
2056 VkAccelerationStructureNV src,
2057 VkCopyAccelerationStructureModeNV mode);
2058
2059VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(
2060 VkCommandBuffer commandBuffer,
2061 VkBuffer raygenShaderBindingTableBuffer,
2062 VkDeviceSize raygenShaderBindingOffset,
2063 VkBuffer missShaderBindingTableBuffer,
2064 VkDeviceSize missShaderBindingOffset,
2065 VkDeviceSize missShaderBindingStride,
2066 VkBuffer hitShaderBindingTableBuffer,
2067 VkDeviceSize hitShaderBindingOffset,
2068 VkDeviceSize hitShaderBindingStride,
2069 VkBuffer callableShaderBindingTableBuffer,
2070 VkDeviceSize callableShaderBindingOffset,
2071 VkDeviceSize callableShaderBindingStride,
2072 uint32_t width,
2073 uint32_t height,
2074 uint32_t depth);
2075
2076VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
2077 VkDevice device,
2078 VkPipelineCache pipelineCache,
2079 uint32_t createInfoCount,
2080 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
2081 const VkAllocationCallbacks* pAllocator,
2082 VkPipeline* pPipelines);
2083
2084VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(
2085 VkDevice device,
2086 VkPipeline pipeline,
2087 uint32_t firstGroup,
2088 uint32_t groupCount,
2089 size_t dataSize,
2090 void* pData);
2091
2092VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(
2093 VkDevice device,
2094 VkAccelerationStructureNV accelerationStructure,
2095 size_t dataSize,
2096 void* pData);
2097
2098VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
2099 VkCommandBuffer commandBuffer,
2100 uint32_t accelerationStructureCount,
2101 const VkAccelerationStructureNV* pAccelerationStructures,
2102 VkQueryType queryType,
2103 VkQueryPool queryPool,
2104 uint32_t firstQuery);
2105
2106VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(
2107 VkDevice device,
2108 VkPipeline pipeline,
2109 uint32_t shader);
2110
2111
2112
2113
2114
2115VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
2116 VkDevice device,
2117 VkExternalMemoryHandleTypeFlagBits handleType,
2118 const void* pHostPointer,
2119 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
2120
2121
2122VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
2123 VkCommandBuffer commandBuffer,
2124 VkPipelineStageFlagBits pipelineStage,
2125 VkBuffer dstBuffer,
2126 VkDeviceSize dstOffset,
2127 uint32_t marker);
2128
2129
2130VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
2131 VkPhysicalDevice physicalDevice,
2132 uint32_t* pTimeDomainCount,
2133 VkTimeDomainEXT* pTimeDomains);
2134
2135VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(
2136 VkDevice device,
2137 uint32_t timestampCount,
2138 const VkCalibratedTimestampInfoEXT* pTimestampInfos,
2139 uint64_t* pTimestamps,
2140 uint64_t* pMaxDeviation);
2141
2142
2143
2144
2145#ifdef VK_USE_PLATFORM_GGP
2146#endif // VK_USE_PLATFORM_GGP
2147
2148
2149
2150
2151
2152VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(
2153 VkCommandBuffer commandBuffer,
2154 uint32_t taskCount,
2155 uint32_t firstTask);
2156
2157VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(
2158 VkCommandBuffer commandBuffer,
2159 VkBuffer buffer,
2160 VkDeviceSize offset,
2161 uint32_t drawCount,
2162 uint32_t stride);
2163
2164VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(
2165 VkCommandBuffer commandBuffer,
2166 VkBuffer buffer,
2167 VkDeviceSize offset,
2168 VkBuffer countBuffer,
2169 VkDeviceSize countBufferOffset,
2170 uint32_t maxDrawCount,
2171 uint32_t stride);
2172
2173
2174
2175
2176VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(
2177 VkCommandBuffer commandBuffer,
2178 uint32_t firstExclusiveScissor,
2179 uint32_t exclusiveScissorCount,
2180 const VkRect2D* pExclusiveScissors);
2181
2182
2183VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(
2184 VkCommandBuffer commandBuffer,
2185 const void* pCheckpointMarker);
2186
2187VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(
2188 VkQueue queue,
2189 uint32_t* pCheckpointDataCount,
2190 VkCheckpointDataNV* pCheckpointData);
2191
2192
2193
2194VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(
2195 VkDevice device,
2196 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
2197
2198VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(
2199 VkDevice device);
2200
2201VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(
2202 VkCommandBuffer commandBuffer,
2203 const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
2204
2205VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(
2206 VkCommandBuffer commandBuffer,
2207 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
2208
2209VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(
2210 VkCommandBuffer commandBuffer,
2211 const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
2212
2213VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL(
2214 VkDevice device,
2215 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
2216 VkPerformanceConfigurationINTEL* pConfiguration);
2217
2218VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(
2219 VkDevice device,
2220 VkPerformanceConfigurationINTEL configuration);
2221
2222VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(
2223 VkQueue queue,
2224 VkPerformanceConfigurationINTEL configuration);
2225
2226VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(
2227 VkDevice device,
2228 VkPerformanceParameterTypeINTEL parameter,
2229 VkPerformanceValueINTEL* pValue);
2230
2231
2232
2233VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(
2234 VkDevice device,
2235 VkSwapchainKHR swapChain,
2236 VkBool32 localDimmingEnable);
2237
2238#ifdef VK_USE_PLATFORM_FUCHSIA
2239
2240VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(
2241 VkInstance instance,
2242 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
2243 const VkAllocationCallbacks* pAllocator,
2244 VkSurfaceKHR* pSurface);
2245#endif // VK_USE_PLATFORM_FUCHSIA
2246
2247#ifdef VK_USE_PLATFORM_METAL_EXT
2248
2249VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
2250 VkInstance instance,
2251 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
2252 const VkAllocationCallbacks* pAllocator,
2253 VkSurfaceKHR* pSurface);
2254#endif // VK_USE_PLATFORM_METAL_EXT
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
2265 VkDevice device,
2266 const VkBufferDeviceAddressInfoEXT* pInfo);
2267
2268
2269
2270
2271VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(
2272 VkPhysicalDevice physicalDevice,
2273 uint32_t* pPropertyCount,
2274 VkCooperativeMatrixPropertiesNV* pProperties);
2275
2276
2277VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
2278 VkPhysicalDevice physicalDevice,
2279 uint32_t* pCombinationCount,
2280 VkFramebufferMixedSamplesCombinationNV* pCombinations);
2281
2282
2283
2284#ifdef VK_USE_PLATFORM_WIN32_KHR
2285
2286VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(
2287 VkPhysicalDevice physicalDevice,
2288 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
2289 uint32_t* pPresentModeCount,
2290 VkPresentModeKHR* pPresentModes);
2291
2292VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(
2293 VkDevice device,
2294 VkSwapchainKHR swapchain);
2295
2296VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(
2297 VkDevice device,
2298 VkSwapchainKHR swapchain);
2299
2300VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(
2301 VkDevice device,
2302 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
2303 VkDeviceGroupPresentModeFlagsKHR* pModes);
2304#endif // VK_USE_PLATFORM_WIN32_KHR
2305
2306
2307VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
2308 VkInstance instance,
2309 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
2310 const VkAllocationCallbacks* pAllocator,
2311 VkSurfaceKHR* pSurface);
2312
2313
2314VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
2315 VkDevice device,
2316 VkQueryPool queryPool,
2317 uint32_t firstQuery,
2318 uint32_t queryCount);
2319
2320
2321
2322
Shannon McPherson0e65e192019-07-17 16:52:21 -0600[diff] [blame]2323
2324
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]2325// Layer object type identifiers
2326enum LayerObjectTypeId {
2327 LayerObjectTypeInstance, // Container for an instance dispatch object
2328 LayerObjectTypeDevice, // Container for a device dispatch object
2329 LayerObjectTypeThreading, // Instance or device threading layer object
2330 LayerObjectTypeParameterValidation, // Instance or device parameter validation layer object
2331 LayerObjectTypeObjectTracker, // Instance or device object tracker layer object
2332 LayerObjectTypeCoreValidation, // Instance or device core validation layer object
2333};
2334
2335struct TEMPLATE_STATE {
2336 VkDescriptorUpdateTemplateKHR desc_update_template;
2337 safe_VkDescriptorUpdateTemplateCreateInfo create_info;
2338
2339 TEMPLATE_STATE(VkDescriptorUpdateTemplateKHR update_template, safe_VkDescriptorUpdateTemplateCreateInfo *pCreateInfo)
2340 : desc_update_template(update_template), create_info(*pCreateInfo) {}
2341};
2342
2343class LAYER_PHYS_DEV_PROPERTIES {
2344public:
2345 VkPhysicalDeviceProperties properties;
2346 std::vector<VkQueueFamilyProperties> queue_family_properties;
2347};
2348
2349typedef enum ValidationCheckDisables {
2350 VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE,
2351 VALIDATION_CHECK_DISABLE_OBJECT_IN_USE,
2352 VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET,
2353 VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE,
2354 VALIDATION_CHECK_DISABLE_QUERY_VALIDATION,
Matthew Ruschd7ef5482019-07-16 22:01:54 -0700[diff] [blame]2355 VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION,
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]2356} ValidationCheckDisables;
2357
2358
2359// CHECK_DISABLED struct is a container for bools that can block validation checks from being performed.
2360// These bools are all "false" by default meaning that all checks are enabled. Enum values can be specified
2361// via the vk_layer_setting.txt config file or at CreateInstance time via the VK_EXT_validation_features extension
2362// that can selectively disable checks.
2363struct CHECK_DISABLED {
2364 bool command_buffer_state; // Skip command buffer state validation
2365 bool object_in_use; // Skip all object in_use checking
2366 bool idle_descriptor_set; // Skip check to verify that descriptor set is not in-use
2367 bool push_constant_range; // Skip push constant range checks
2368 bool query_validation; // Disable all core validation query-related checks
Matthew Ruschd7ef5482019-07-16 22:01:54 -0700[diff] [blame]2369 bool image_layout_validation; // Disable image layout validation
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]2370 bool object_tracking; // Disable object lifetime validation
2371 bool core_checks; // Disable core validation checks
2372 bool thread_safety; // Disable thread safety validation
2373 bool stateless_checks; // Disable stateless validation checks
2374 bool handle_wrapping; // Disable unique handles/handle wrapping
2375 bool shader_validation; // Skip validation for shaders
2376
2377 void SetAll(bool value) { std::fill(&command_buffer_state, &shader_validation + 1, value); }
2378};
2379
2380struct CHECK_ENABLED {
2381 bool gpu_validation;
2382 bool gpu_validation_reserve_binding_slot;
2383
2384 void SetAll(bool value) { std::fill(&gpu_validation, &gpu_validation_reserve_binding_slot + 1, value); }
2385};
2386
2387// Layer chassis validation object base class definition
2388class ValidationObject {
2389 public:
2390 uint32_t api_version;
2391 debug_report_data* report_data = nullptr;
2392 std::vector<VkDebugReportCallbackEXT> logging_callback;
2393 std::vector<VkDebugUtilsMessengerEXT> logging_messenger;
2394
2395 VkLayerInstanceDispatchTable instance_dispatch_table;
2396 VkLayerDispatchTable device_dispatch_table;
2397
2398 InstanceExtensions instance_extensions;
2399 DeviceExtensions device_extensions = {};
2400 CHECK_DISABLED disabled = {};
2401 CHECK_ENABLED enabled = {};
2402
2403 VkInstance instance = VK_NULL_HANDLE;
2404 VkPhysicalDevice physical_device = VK_NULL_HANDLE;
2405 VkDevice device = VK_NULL_HANDLE;
2406 LAYER_PHYS_DEV_PROPERTIES phys_dev_properties = {};
2407
2408 std::vector<ValidationObject*> object_dispatch;
2409 LayerObjectTypeId container_type;
2410
2411 std::string layer_name = "CHASSIS";
2412
2413 // Constructor
2414 ValidationObject(){};
2415 // Destructor
2416 virtual ~ValidationObject() {};
2417
2418 std::mutex validation_object_mutex;
2419 virtual std::unique_lock<std::mutex> write_lock() {
2420 return std::unique_lock<std::mutex>(validation_object_mutex);
2421 }
2422
2423 ValidationObject* GetValidationObject(std::vector<ValidationObject*>& object_dispatch, LayerObjectTypeId object_type) {
2424 for (auto validation_object : object_dispatch) {
2425 if (validation_object->container_type == object_type) {
2426 return validation_object;
2427 }
2428 }
2429 return nullptr;
2430 };
2431
2432 // Handle Wrapping Data
2433 // Reverse map display handles
2434 std::unordered_map<VkDisplayKHR, uint64_t> display_id_reverse_mapping;
2435 // Wrapping Descriptor Template Update structures requires access to the template createinfo structs
2436 std::unordered_map<uint64_t, std::unique_ptr<TEMPLATE_STATE>> desc_template_createinfo_map;
2437 struct SubpassesUsageStates {
2438 std::unordered_set<uint32_t> subpasses_using_color_attachment;
2439 std::unordered_set<uint32_t> subpasses_using_depthstencil_attachment;
2440 };
2441 // Uses unwrapped handles
2442 std::unordered_map<VkRenderPass, SubpassesUsageStates> renderpasses_states;
2443 // Map of wrapped swapchain handles to arrays of wrapped swapchain image IDs
2444 // Each swapchain has an immutable list of wrapped swapchain image IDs -- always return these IDs if they exist
2445 std::unordered_map<VkSwapchainKHR, std::vector<VkImage>> swapchain_wrapped_image_handle_map;
2446 // Map of wrapped descriptor pools to set of wrapped descriptor sets allocated from each pool
2447 std::unordered_map<VkDescriptorPool, std::unordered_set<VkDescriptorSet>> pool_descriptor_sets_map;
2448
2449
2450 // Unwrap a handle. Must hold lock.
2451 template <typename HandleType>
2452 HandleType Unwrap(HandleType wrappedHandle) {
2453 // TODO: don't use operator[] here.
2454 return (HandleType)unique_id_mapping[reinterpret_cast<uint64_t const &>(wrappedHandle)];
2455 }
2456
2457 // Wrap a newly created handle with a new unique ID, and return the new ID -- must hold lock.
2458 template <typename HandleType>
2459 HandleType WrapNew(HandleType newlyCreatedHandle) {
2460 auto unique_id = global_unique_id++;
2461 unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
2462 return (HandleType)unique_id;
2463 }
2464
2465 // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup. Must hold lock.
2466 VkDisplayKHR WrapDisplay(VkDisplayKHR newlyCreatedHandle, ValidationObject *map_data) {
2467 auto unique_id = global_unique_id++;
2468 unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
2469 map_data->display_id_reverse_mapping[newlyCreatedHandle] = unique_id;
2470 return (VkDisplayKHR)unique_id;
2471 }
2472
2473 // VkDisplayKHR objects don't have a single point of creation, so we need to see if one already exists in the map before
2474 // creating another. Must hold lock.
2475 VkDisplayKHR MaybeWrapDisplay(VkDisplayKHR handle, ValidationObject *map_data) {
2476 // See if this display is already known
2477 auto it = map_data->display_id_reverse_mapping.find(handle);
2478 if (it != map_data->display_id_reverse_mapping.end()) return (VkDisplayKHR)it->second;
2479 // Unknown, so wrap
2480 return WrapDisplay(handle, map_data);
2481 }
2482
2483 // Pre/post hook point declarations
2484 virtual bool PreCallValidateCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { return false; };
2485 virtual void PreCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {};
2486 virtual void PostCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, VkResult result) {};
2487 virtual bool PreCallValidateDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { return false; };
2488 virtual void PreCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {};
2489 virtual void PostCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {};
2490 virtual bool PreCallValidateEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { return false; };
2491 virtual void PreCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {};
2492 virtual void PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, VkResult result) {};
2493 virtual bool PreCallValidateGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { return false; };
2494 virtual void PreCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {};
2495 virtual void PostCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {};
2496 virtual bool PreCallValidateGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { return false; };
2497 virtual void PreCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {};
2498 virtual void PostCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {};
2499 virtual bool PreCallValidateGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { return false; };
2500 virtual void PreCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {};
2501 virtual void PostCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, VkResult result) {};
2502 virtual bool PreCallValidateGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { return false; };
2503 virtual void PreCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {};
2504 virtual void PostCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {};
2505 virtual bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { return false; };
2506 virtual void PreCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {};
2507 virtual void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {};
2508 virtual bool PreCallValidateGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { return false; };
2509 virtual void PreCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {};
2510 virtual void PostCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {};
2511 virtual bool PreCallValidateGetInstanceProcAddr(VkInstance instance, const char* pName) { return false; };
2512 virtual void PreCallRecordGetInstanceProcAddr(VkInstance instance, const char* pName) {};
2513 virtual void PostCallRecordGetInstanceProcAddr(VkInstance instance, const char* pName) {};
2514 virtual bool PreCallValidateGetDeviceProcAddr(VkDevice device, const char* pName) { return false; };
2515 virtual void PreCallRecordGetDeviceProcAddr(VkDevice device, const char* pName) {};
2516 virtual void PostCallRecordGetDeviceProcAddr(VkDevice device, const char* pName) {};
2517 virtual bool PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { return false; };
2518 virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {};
2519 virtual void PostCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, VkResult result) {};
2520 virtual bool PreCallValidateDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { return false; };
2521 virtual void PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {};
2522 virtual void PostCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {};
2523 virtual bool PreCallValidateEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { return false; };
2524 virtual void PreCallRecordEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {};
2525 virtual void PostCallRecordEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult result) {};
2526 virtual bool PreCallValidateEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { return false; };
2527 virtual void PreCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {};
2528 virtual void PostCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult result) {};
2529 virtual bool PreCallValidateEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return false; };
2530 virtual void PreCallRecordEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {};
2531 virtual void PostCallRecordEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult result) {};
2532 virtual bool PreCallValidateEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return false; };
2533 virtual void PreCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {};
2534 virtual void PostCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult result) {};
2535 virtual bool PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { return false; };
2536 virtual void PreCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {};
2537 virtual void PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {};
2538 virtual bool PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { return false; };
2539 virtual void PreCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {};
2540 virtual void PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, VkResult result) {};
2541 virtual bool PreCallValidateQueueWaitIdle(VkQueue queue) { return false; };
2542 virtual void PreCallRecordQueueWaitIdle(VkQueue queue) {};
2543 virtual void PostCallRecordQueueWaitIdle(VkQueue queue, VkResult result) {};
2544 virtual bool PreCallValidateDeviceWaitIdle(VkDevice device) { return false; };
2545 virtual void PreCallRecordDeviceWaitIdle(VkDevice device) {};
2546 virtual void PostCallRecordDeviceWaitIdle(VkDevice device, VkResult result) {};
2547 virtual bool PreCallValidateAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { return false; };
2548 virtual void PreCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {};
2549 virtual void PostCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, VkResult result) {};
2550 virtual bool PreCallValidateFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { return false; };
2551 virtual void PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {};
2552 virtual void PostCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {};
2553 virtual bool PreCallValidateMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { return false; };
2554 virtual void PreCallRecordMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {};
2555 virtual void PostCallRecordMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData, VkResult result) {};
2556 virtual bool PreCallValidateUnmapMemory(VkDevice device, VkDeviceMemory memory) { return false; };
2557 virtual void PreCallRecordUnmapMemory(VkDevice device, VkDeviceMemory memory) {};
2558 virtual void PostCallRecordUnmapMemory(VkDevice device, VkDeviceMemory memory) {};
2559 virtual bool PreCallValidateFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { return false; };
2560 virtual void PreCallRecordFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {};
2561 virtual void PostCallRecordFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult result) {};
2562 virtual bool PreCallValidateInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { return false; };
2563 virtual void PreCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {};
2564 virtual void PostCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult result) {};
2565 virtual bool PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { return false; };
2566 virtual void PreCallRecordGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {};
2567 virtual void PostCallRecordGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {};
2568 virtual bool PreCallValidateBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { return false; };
2569 virtual void PreCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {};
2570 virtual void PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult result) {};
2571 virtual bool PreCallValidateBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { return false; };
2572 virtual void PreCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {};
2573 virtual void PostCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult result) {};
2574 virtual bool PreCallValidateGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { return false; };
2575 virtual void PreCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {};
2576 virtual void PostCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {};
2577 virtual bool PreCallValidateGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { return false; };
2578 virtual void PreCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {};
2579 virtual void PostCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {};
2580 virtual bool PreCallValidateGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { return false; };
2581 virtual void PreCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {};
2582 virtual void PostCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {};
2583 virtual bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { return false; };
2584 virtual void PreCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {};
2585 virtual void PostCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {};
2586 virtual bool PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { return false; };
2587 virtual void PreCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {};
2588 virtual void PostCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, VkResult result) {};
2589 virtual bool PreCallValidateCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { return false; };
2590 virtual void PreCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {};
2591 virtual void PostCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult result) {};
2592 virtual bool PreCallValidateDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { return false; };
2593 virtual void PreCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {};
2594 virtual void PostCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {};
2595 virtual bool PreCallValidateResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { return false; };
2596 virtual void PreCallRecordResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {};
2597 virtual void PostCallRecordResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkResult result) {};
2598 virtual bool PreCallValidateGetFenceStatus(VkDevice device, VkFence fence) { return false; };
2599 virtual void PreCallRecordGetFenceStatus(VkDevice device, VkFence fence) {};
2600 virtual void PostCallRecordGetFenceStatus(VkDevice device, VkFence fence, VkResult result) {};
2601 virtual bool PreCallValidateWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { return false; };
2602 virtual void PreCallRecordWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {};
2603 virtual void PostCallRecordWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, VkResult result) {};
2604 virtual bool PreCallValidateCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { return false; };
2605 virtual void PreCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {};
2606 virtual void PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, VkResult result) {};
2607 virtual bool PreCallValidateDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { return false; };
2608 virtual void PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {};
2609 virtual void PostCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {};
2610 virtual bool PreCallValidateCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { return false; };
2611 virtual void PreCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {};
2612 virtual void PostCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, VkResult result) {};
2613 virtual bool PreCallValidateDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { return false; };
2614 virtual void PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {};
2615 virtual void PostCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {};
2616 virtual bool PreCallValidateGetEventStatus(VkDevice device, VkEvent event) { return false; };
2617 virtual void PreCallRecordGetEventStatus(VkDevice device, VkEvent event) {};
2618 virtual void PostCallRecordGetEventStatus(VkDevice device, VkEvent event, VkResult result) {};
2619 virtual bool PreCallValidateSetEvent(VkDevice device, VkEvent event) { return false; };
2620 virtual void PreCallRecordSetEvent(VkDevice device, VkEvent event) {};
2621 virtual void PostCallRecordSetEvent(VkDevice device, VkEvent event, VkResult result) {};
2622 virtual bool PreCallValidateResetEvent(VkDevice device, VkEvent event) { return false; };
2623 virtual void PreCallRecordResetEvent(VkDevice device, VkEvent event) {};
2624 virtual void PostCallRecordResetEvent(VkDevice device, VkEvent event, VkResult result) {};
2625 virtual bool PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { return false; };
2626 virtual void PreCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {};
2627 virtual void PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, VkResult result) {};
2628 virtual bool PreCallValidateDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { return false; };
2629 virtual void PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {};
2630 virtual void PostCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {};
2631 virtual bool PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { return false; };
2632 virtual void PreCallRecordGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {};
2633 virtual void PostCallRecordGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, VkResult result) {};
2634 virtual bool PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { return false; };
2635 virtual void PreCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {};
2636 virtual void PostCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, VkResult result) {};
2637 virtual bool PreCallValidateDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { return false; };
2638 virtual void PreCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {};
2639 virtual void PostCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {};
2640 virtual bool PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { return false; };
2641 virtual void PreCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {};
2642 virtual void PostCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, VkResult result) {};
2643 virtual bool PreCallValidateDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { return false; };
2644 virtual void PreCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {};
2645 virtual void PostCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {};
2646 virtual bool PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { return false; };
2647 virtual void PreCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {};
2648 virtual void PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, VkResult result) {};
2649 virtual bool PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { return false; };
2650 virtual void PreCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {};
2651 virtual void PostCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {};
2652 virtual bool PreCallValidateGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { return false; };
2653 virtual void PreCallRecordGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {};
2654 virtual void PostCallRecordGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {};
2655 virtual bool PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { return false; };
2656 virtual void PreCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {};
2657 virtual void PostCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, VkResult result) {};
2658 virtual bool PreCallValidateDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { return false; };
2659 virtual void PreCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {};
2660 virtual void PostCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {};
2661 virtual bool PreCallValidateCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { return false; };
2662 virtual void PreCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {};
2663 virtual void PostCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult result) {};
2664 virtual bool PreCallValidateDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { return false; };
2665 virtual void PreCallRecordDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {};
2666 virtual void PostCallRecordDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {};
2667 virtual bool PreCallValidateCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { return false; };
2668 virtual void PreCallRecordCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {};
2669 virtual void PostCallRecordCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, VkResult result) {};
2670 virtual bool PreCallValidateDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { return false; };
2671 virtual void PreCallRecordDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {};
2672 virtual void PostCallRecordDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {};
2673 virtual bool PreCallValidateGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { return false; };
2674 virtual void PreCallRecordGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {};
2675 virtual void PostCallRecordGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, VkResult result) {};
2676 virtual bool PreCallValidateMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { return false; };
2677 virtual void PreCallRecordMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {};
2678 virtual void PostCallRecordMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, VkResult result) {};
2679 virtual bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; };
2680 virtual void PreCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {};
2681 virtual void PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {};
2682 virtual bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; };
2683 virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {};
2684 virtual void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {};
2685 virtual bool PreCallValidateDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { return false; };
2686 virtual void PreCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {};
2687 virtual void PostCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {};
2688 virtual bool PreCallValidateCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { return false; };
2689 virtual void PreCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {};
2690 virtual void PostCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, VkResult result) {};
2691 virtual bool PreCallValidateDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { return false; };
2692 virtual void PreCallRecordDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {};
2693 virtual void PostCallRecordDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {};
2694 virtual bool PreCallValidateCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { return false; };
2695 virtual void PreCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {};
2696 virtual void PostCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, VkResult result) {};
2697 virtual bool PreCallValidateDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { return false; };
2698 virtual void PreCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {};
2699 virtual void PostCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {};
2700 virtual bool PreCallValidateCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { return false; };
2701 virtual void PreCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {};
2702 virtual void PostCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, VkResult result) {};
2703 virtual bool PreCallValidateDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { return false; };
2704 virtual void PreCallRecordDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {};
2705 virtual void PostCallRecordDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {};
2706 virtual bool PreCallValidateCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { return false; };
2707 virtual void PreCallRecordCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {};
2708 virtual void PostCallRecordCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, VkResult result) {};
2709 virtual bool PreCallValidateDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { return false; };
2710 virtual void PreCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {};
2711 virtual void PostCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {};
2712 virtual bool PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { return false; };
2713 virtual void PreCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {};
2714 virtual void PostCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, VkResult result) {};
2715 virtual bool PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { return false; };
2716 virtual void PreCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {};
2717 virtual void PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, VkResult result) {};
2718 virtual bool PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { return false; };
2719 virtual void PreCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {};
2720 virtual void PostCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, VkResult result) {};
2721 virtual bool PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { return false; };
2722 virtual void PreCallRecordUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {};
2723 virtual void PostCallRecordUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {};
2724 virtual bool PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { return false; };
2725 virtual void PreCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {};
2726 virtual void PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, VkResult result) {};
2727 virtual bool PreCallValidateDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { return false; };
2728 virtual void PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {};
2729 virtual void PostCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {};
2730 virtual bool PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { return false; };
2731 virtual void PreCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {};
2732 virtual void PostCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result) {};
2733 virtual bool PreCallValidateDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { return false; };
2734 virtual void PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {};
2735 virtual void PostCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {};
2736 virtual bool PreCallValidateGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { return false; };
2737 virtual void PreCallRecordGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {};
2738 virtual void PostCallRecordGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {};
2739 virtual bool PreCallValidateCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { return false; };
2740 virtual void PreCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {};
2741 virtual void PostCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, VkResult result) {};
2742 virtual bool PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { return false; };
2743 virtual void PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {};
2744 virtual void PostCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {};
2745 virtual bool PreCallValidateResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { return false; };
2746 virtual void PreCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {};
2747 virtual void PostCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, VkResult result) {};
2748 virtual bool PreCallValidateAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { return false; };
2749 virtual void PreCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {};
2750 virtual void PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, VkResult result) {};
2751 virtual bool PreCallValidateFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { return false; };
2752 virtual void PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2753 virtual void PostCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2754 virtual bool PreCallValidateBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { return false; };
2755 virtual void PreCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {};
2756 virtual void PostCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, VkResult result) {};
2757 virtual bool PreCallValidateEndCommandBuffer(VkCommandBuffer commandBuffer) { return false; };
2758 virtual void PreCallRecordEndCommandBuffer(VkCommandBuffer commandBuffer) {};
2759 virtual void PostCallRecordEndCommandBuffer(VkCommandBuffer commandBuffer, VkResult result) {};
2760 virtual bool PreCallValidateResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { return false; };
2761 virtual void PreCallRecordResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {};
2762 virtual void PostCallRecordResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, VkResult result) {};
2763 virtual bool PreCallValidateCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { return false; };
2764 virtual void PreCallRecordCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {};
2765 virtual void PostCallRecordCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {};
2766 virtual bool PreCallValidateCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { return false; };
2767 virtual void PreCallRecordCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {};
2768 virtual void PostCallRecordCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {};
2769 virtual bool PreCallValidateCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { return false; };
2770 virtual void PreCallRecordCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {};
2771 virtual void PostCallRecordCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {};
2772 virtual bool PreCallValidateCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { return false; };
2773 virtual void PreCallRecordCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {};
2774 virtual void PostCallRecordCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {};
2775 virtual bool PreCallValidateCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { return false; };
2776 virtual void PreCallRecordCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {};
2777 virtual void PostCallRecordCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {};
2778 virtual bool PreCallValidateCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { return false; };
2779 virtual void PreCallRecordCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {};
2780 virtual void PostCallRecordCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {};
2781 virtual bool PreCallValidateCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { return false; };
2782 virtual void PreCallRecordCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {};
2783 virtual void PostCallRecordCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {};
2784 virtual bool PreCallValidateCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { return false; };
2785 virtual void PreCallRecordCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {};
2786 virtual void PostCallRecordCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {};
2787 virtual bool PreCallValidateCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { return false; };
2788 virtual void PreCallRecordCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {};
2789 virtual void PostCallRecordCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {};
2790 virtual bool PreCallValidateCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { return false; };
2791 virtual void PreCallRecordCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {};
2792 virtual void PostCallRecordCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {};
2793 virtual bool PreCallValidateCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { return false; };
2794 virtual void PreCallRecordCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {};
2795 virtual void PostCallRecordCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {};
2796 virtual bool PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { return false; };
2797 virtual void PreCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {};
2798 virtual void PostCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {};
2799 virtual bool PreCallValidateCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { return false; };
2800 virtual void PreCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {};
2801 virtual void PostCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {};
2802 virtual bool PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { return false; };
2803 virtual void PreCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {};
2804 virtual void PostCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {};
2805 virtual bool PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { return false; };
2806 virtual void PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {};
2807 virtual void PostCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {};
2808 virtual bool PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { return false; };
2809 virtual void PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2810 virtual void PostCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2811 virtual bool PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { return false; };
2812 virtual void PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2813 virtual void PostCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2814 virtual bool PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { return false; };
2815 virtual void PreCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2816 virtual void PostCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2817 virtual bool PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { return false; };
2818 virtual void PreCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {};
2819 virtual void PostCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {};
2820 virtual bool PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { return false; };
2821 virtual void PreCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {};
2822 virtual void PostCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {};
2823 virtual bool PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { return false; };
2824 virtual void PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {};
2825 virtual void PostCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {};
2826 virtual bool PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { return false; };
2827 virtual void PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {};
2828 virtual void PostCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {};
2829 virtual bool PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { return false; };
2830 virtual void PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2831 virtual void PostCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2832 virtual bool PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { return false; };
2833 virtual void PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2834 virtual void PostCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2835 virtual bool PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { return false; };
2836 virtual void PreCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {};
2837 virtual void PostCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {};
2838 virtual bool PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { return false; };
2839 virtual void PreCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {};
2840 virtual void PostCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {};
2841 virtual bool PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { return false; };
2842 virtual void PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2843 virtual void PostCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2844 virtual bool PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { return false; };
2845 virtual void PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2846 virtual void PostCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2847 virtual bool PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { return false; };
2848 virtual void PreCallRecordCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {};
2849 virtual void PostCallRecordCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {};
2850 virtual bool PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { return false; };
2851 virtual void PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {};
2852 virtual void PostCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {};
2853 virtual bool PreCallValidateCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { return false; };
2854 virtual void PreCallRecordCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2855 virtual void PostCallRecordCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2856 virtual bool PreCallValidateCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { return false; };
2857 virtual void PreCallRecordCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2858 virtual void PostCallRecordCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2859 virtual bool 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) { return false; };
2860 virtual void PreCallRecordCmdWaitEvents(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) {};
2861 virtual void PostCallRecordCmdWaitEvents(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) {};
2862 virtual bool 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) { return false; };
2863 virtual void PreCallRecordCmdPipelineBarrier(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) {};
2864 virtual void PostCallRecordCmdPipelineBarrier(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) {};
2865 virtual bool PreCallValidateCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { return false; };
2866 virtual void PreCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {};
2867 virtual void PostCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {};
2868 virtual bool PreCallValidateCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { return false; };
2869 virtual void PreCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {};
2870 virtual void PostCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {};
2871 virtual bool PreCallValidateCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { return false; };
2872 virtual void PreCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
2873 virtual void PostCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
2874 virtual bool PreCallValidateCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { return false; };
2875 virtual void PreCallRecordCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {};
2876 virtual void PostCallRecordCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {};
2877 virtual bool PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { return false; };
2878 virtual void PreCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {};
2879 virtual void PostCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {};
2880 virtual bool PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { return false; };
2881 virtual void PreCallRecordCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {};
2882 virtual void PostCallRecordCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {};
2883 virtual bool PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { return false; };
2884 virtual void PreCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {};
2885 virtual void PostCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {};
2886 virtual bool PreCallValidateCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { return false; };
2887 virtual void PreCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {};
2888 virtual void PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {};
2889 virtual bool PreCallValidateCmdEndRenderPass(VkCommandBuffer commandBuffer) { return false; };
2890 virtual void PreCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) {};
2891 virtual void PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) {};
2892 virtual bool PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { return false; };
2893 virtual void PreCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2894 virtual void PostCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2895 virtual bool PreCallValidateBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { return false; };
2896 virtual void PreCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {};
2897 virtual void PostCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult result) {};
2898 virtual bool PreCallValidateBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { return false; };
2899 virtual void PreCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {};
2900 virtual void PostCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult result) {};
2901 virtual bool PreCallValidateGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { return false; };
2902 virtual void PreCallRecordGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
2903 virtual void PostCallRecordGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
2904 virtual bool PreCallValidateCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { return false; };
2905 virtual void PreCallRecordCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
2906 virtual void PostCallRecordCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
2907 virtual bool PreCallValidateCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { return false; };
2908 virtual void PreCallRecordCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2909 virtual void PostCallRecordCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2910 virtual bool PreCallValidateEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { return false; };
2911 virtual void PreCallRecordEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {};
2912 virtual void PostCallRecordEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult result) {};
2913 virtual bool PreCallValidateGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
2914 virtual void PreCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2915 virtual void PostCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2916 virtual bool PreCallValidateGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
2917 virtual void PreCallRecordGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2918 virtual void PostCallRecordGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2919 virtual bool PreCallValidateGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { return false; };
2920 virtual void PreCallRecordGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
2921 virtual void PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
2922 virtual bool PreCallValidateGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { return false; };
2923 virtual void PreCallRecordGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
2924 virtual void PostCallRecordGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
2925 virtual bool PreCallValidateGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { return false; };
2926 virtual void PreCallRecordGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
2927 virtual void PostCallRecordGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
2928 virtual bool PreCallValidateGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { return false; };
2929 virtual void PreCallRecordGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
2930 virtual void PostCallRecordGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
2931 virtual bool PreCallValidateGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { return false; };
2932 virtual void PreCallRecordGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {};
2933 virtual void PostCallRecordGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult result) {};
2934 virtual bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { return false; };
2935 virtual void PreCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
2936 virtual void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
2937 virtual bool PreCallValidateGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { return false; };
2938 virtual void PreCallRecordGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
2939 virtual void PostCallRecordGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
2940 virtual bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { return false; };
2941 virtual void PreCallRecordGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
2942 virtual void PostCallRecordGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
2943 virtual bool PreCallValidateTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { return false; };
2944 virtual void PreCallRecordTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
2945 virtual void PostCallRecordTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
2946 virtual bool PreCallValidateGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { return false; };
2947 virtual void PreCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {};
2948 virtual void PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {};
2949 virtual bool PreCallValidateCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return false; };
2950 virtual void PreCallRecordCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {};
2951 virtual void PostCallRecordCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result) {};
2952 virtual bool PreCallValidateDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { return false; };
2953 virtual void PreCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
2954 virtual void PostCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
2955 virtual bool PreCallValidateCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { return false; };
2956 virtual void PreCallRecordCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {};
2957 virtual void PostCallRecordCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult result) {};
2958 virtual bool PreCallValidateDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { return false; };
2959 virtual void PreCallRecordDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
2960 virtual void PostCallRecordDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
2961 virtual bool PreCallValidateUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { return false; };
2962 virtual void PreCallRecordUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
2963 virtual void PostCallRecordUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
2964 virtual bool PreCallValidateGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { return false; };
2965 virtual void PreCallRecordGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
2966 virtual void PostCallRecordGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
2967 virtual bool PreCallValidateGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { return false; };
2968 virtual void PreCallRecordGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
2969 virtual void PostCallRecordGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
2970 virtual bool PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { return false; };
2971 virtual void PreCallRecordGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
2972 virtual void PostCallRecordGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
2973 virtual bool PreCallValidateGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { return false; };
2974 virtual void PreCallRecordGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
2975 virtual void PostCallRecordGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
2976 virtual bool PreCallValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { return false; };
2977 virtual void PreCallRecordDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {};
2978 virtual void PostCallRecordDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {};
2979 virtual bool PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { return false; };
2980 virtual void PreCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {};
2981 virtual void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported, VkResult result) {};
2982 virtual bool PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { return false; };
2983 virtual void PreCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {};
2984 virtual void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, VkResult result) {};
2985 virtual bool PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { return false; };
2986 virtual void PreCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {};
2987 virtual void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats, VkResult result) {};
2988 virtual bool PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { return false; };
2989 virtual void PreCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {};
2990 virtual void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, VkResult result) {};
2991 virtual bool PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { return false; };
2992 virtual void PreCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {};
2993 virtual void PostCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain, VkResult result) {};
2994 virtual bool PreCallValidateDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { return false; };
2995 virtual void PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {};
2996 virtual void PostCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {};
2997 virtual bool PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { return false; };
2998 virtual void PreCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {};
2999 virtual void PostCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages, VkResult result) {};
3000 virtual bool PreCallValidateAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { return false; };
3001 virtual void PreCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {};
3002 virtual void PostCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex, VkResult result) {};
3003 virtual bool PreCallValidateQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { return false; };
3004 virtual void PreCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {};
3005 virtual void PostCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo, VkResult result) {};
3006 virtual bool PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { return false; };
3007 virtual void PreCallRecordGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {};
3008 virtual void PostCallRecordGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, VkResult result) {};
3009 virtual bool PreCallValidateGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { return false; };
3010 virtual void PreCallRecordGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {};
3011 virtual void PostCallRecordGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes, VkResult result) {};
3012 virtual bool PreCallValidateGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { return false; };
3013 virtual void PreCallRecordGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) {};
3014 virtual void PostCallRecordGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects, VkResult result) {};
3015 virtual bool PreCallValidateAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { return false; };
3016 virtual void PreCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) {};
3017 virtual void PostCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, VkResult result) {};
3018 virtual bool PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) { return false; };
3019 virtual void PreCallRecordGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) {};
3020 virtual void PostCallRecordGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties, VkResult result) {};
3021 virtual bool PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) { return false; };
3022 virtual void PreCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) {};
3023 virtual void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties, VkResult result) {};
3024 virtual bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { return false; };
3025 virtual void PreCallRecordGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) {};
3026 virtual void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays, VkResult result) {};
3027 virtual bool PreCallValidateGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) { return false; };
3028 virtual void PreCallRecordGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) {};
3029 virtual void PostCallRecordGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties, VkResult result) {};
3030 virtual bool PreCallValidateCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { return false; };
3031 virtual void PreCallRecordCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {};
3032 virtual void PostCallRecordCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode, VkResult result) {};
3033 virtual bool PreCallValidateGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) { return false; };
3034 virtual void PreCallRecordGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) {};
3035 virtual void PostCallRecordGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities, VkResult result) {};
3036 virtual bool PreCallValidateCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3037 virtual void PreCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3038 virtual void PostCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3039 virtual bool PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { return false; };
3040 virtual void PreCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {};
3041 virtual void PostCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains, VkResult result) {};
3042#ifdef VK_USE_PLATFORM_XLIB_KHR
3043 virtual bool PreCallValidateCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3044 virtual void PreCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3045 virtual void PostCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3046#endif
3047#ifdef VK_USE_PLATFORM_XLIB_KHR
3048 virtual bool PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { return false; };
3049 virtual void PreCallRecordGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) {};
3050 virtual void PostCallRecordGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) {};
3051#endif
3052#ifdef VK_USE_PLATFORM_XCB_KHR
3053 virtual bool PreCallValidateCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3054 virtual void PreCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3055 virtual void PostCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3056#endif
3057#ifdef VK_USE_PLATFORM_XCB_KHR
3058 virtual bool PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { return false; };
3059 virtual void PreCallRecordGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) {};
3060 virtual void PostCallRecordGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) {};
3061#endif
3062#ifdef VK_USE_PLATFORM_WAYLAND_KHR
3063 virtual bool PreCallValidateCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3064 virtual void PreCallRecordCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3065 virtual void PostCallRecordCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3066#endif
3067#ifdef VK_USE_PLATFORM_WAYLAND_KHR
3068 virtual bool PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { return false; };
3069 virtual void PreCallRecordGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) {};
3070 virtual void PostCallRecordGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) {};
3071#endif
3072#ifdef VK_USE_PLATFORM_ANDROID_KHR
3073 virtual bool PreCallValidateCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3074 virtual void PreCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3075 virtual void PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3076#endif
3077#ifdef VK_USE_PLATFORM_WIN32_KHR
3078 virtual bool PreCallValidateCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3079 virtual void PreCallRecordCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3080 virtual void PostCallRecordCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3081#endif
3082#ifdef VK_USE_PLATFORM_WIN32_KHR
3083 virtual bool PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { return false; };
3084 virtual void PreCallRecordGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {};
3085 virtual void PostCallRecordGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {};
3086#endif
3087 virtual bool PreCallValidateGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { return false; };
3088 virtual void PreCallRecordGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
3089 virtual void PostCallRecordGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
3090 virtual bool PreCallValidateGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { return false; };
3091 virtual void PreCallRecordGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
3092 virtual void PostCallRecordGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
3093 virtual bool PreCallValidateGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { return false; };
3094 virtual void PreCallRecordGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
3095 virtual void PostCallRecordGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
3096 virtual bool PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { return false; };
3097 virtual void PreCallRecordGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {};
3098 virtual void PostCallRecordGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult result) {};
3099 virtual bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { return false; };
3100 virtual void PreCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
3101 virtual void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
3102 virtual bool PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { return false; };
3103 virtual void PreCallRecordGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
3104 virtual void PostCallRecordGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
3105 virtual bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { return false; };
3106 virtual void PreCallRecordGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
3107 virtual void PostCallRecordGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
3108 virtual bool PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { return false; };
3109 virtual void PreCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
3110 virtual void PostCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
3111 virtual bool PreCallValidateCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) { return false; };
3112 virtual void PreCallRecordCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
3113 virtual void PostCallRecordCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
3114 virtual bool PreCallValidateCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { return false; };
3115 virtual void PreCallRecordCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
3116 virtual void PostCallRecordCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
3117 virtual bool PreCallValidateTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { return false; };
3118 virtual void PreCallRecordTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
3119 virtual void PostCallRecordTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
3120 virtual bool PreCallValidateEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { return false; };
3121 virtual void PreCallRecordEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {};
3122 virtual void PostCallRecordEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult result) {};
3123 virtual bool PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { return false; };
3124 virtual void PreCallRecordGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
3125 virtual void PostCallRecordGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
3126#ifdef VK_USE_PLATFORM_WIN32_KHR
3127 virtual bool PreCallValidateGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { return false; };
3128 virtual void PreCallRecordGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {};
3129 virtual void PostCallRecordGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, VkResult result) {};
3130#endif
3131#ifdef VK_USE_PLATFORM_WIN32_KHR
3132 virtual bool PreCallValidateGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { return false; };
3133 virtual void PreCallRecordGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {};
3134 virtual void PostCallRecordGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, VkResult result) {};
3135#endif
3136 virtual bool PreCallValidateGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { return false; };
3137 virtual void PreCallRecordGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {};
3138 virtual void PostCallRecordGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result) {};
3139 virtual bool PreCallValidateGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { return false; };
3140 virtual void PreCallRecordGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) {};
3141 virtual void PostCallRecordGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties, VkResult result) {};
3142 virtual bool PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { return false; };
3143 virtual void PreCallRecordGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
3144 virtual void PostCallRecordGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
3145#ifdef VK_USE_PLATFORM_WIN32_KHR
3146 virtual bool PreCallValidateImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { return false; };
3147 virtual void PreCallRecordImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {};
3148 virtual void PostCallRecordImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, VkResult result) {};
3149#endif
3150#ifdef VK_USE_PLATFORM_WIN32_KHR
3151 virtual bool PreCallValidateGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { return false; };
3152 virtual void PreCallRecordGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {};
3153 virtual void PostCallRecordGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, VkResult result) {};
3154#endif
3155 virtual bool PreCallValidateImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { return false; };
3156 virtual void PreCallRecordImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {};
3157 virtual void PostCallRecordImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, VkResult result) {};
3158 virtual bool PreCallValidateGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { return false; };
3159 virtual void PreCallRecordGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {};
3160 virtual void PostCallRecordGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result) {};
3161 virtual bool PreCallValidateCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { return false; };
3162 virtual void PreCallRecordCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {};
3163 virtual void PostCallRecordCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {};
3164 virtual bool PreCallValidateCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { return false; };
3165 virtual void PreCallRecordCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {};
3166 virtual void PostCallRecordCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {};
3167 virtual bool PreCallValidateCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { return false; };
3168 virtual void PreCallRecordCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {};
3169 virtual void PostCallRecordCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult result) {};
3170 virtual bool PreCallValidateDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { return false; };
3171 virtual void PreCallRecordDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
3172 virtual void PostCallRecordDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
3173 virtual bool PreCallValidateUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { return false; };
3174 virtual void PreCallRecordUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
3175 virtual void PostCallRecordUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
3176 virtual bool PreCallValidateCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { return false; };
3177 virtual void PreCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {};
3178 virtual void PostCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result) {};
3179 virtual bool PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) { return false; };
3180 virtual void PreCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {};
3181 virtual void PostCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {};
3182 virtual bool PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) { return false; };
3183 virtual void PreCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3184 virtual void PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3185 virtual bool PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) { return false; };
3186 virtual void PreCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3187 virtual void PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3188 virtual bool PreCallValidateGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { return false; };
3189 virtual void PreCallRecordGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {};
3190 virtual void PostCallRecordGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain, VkResult result) {};
3191 virtual bool PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { return false; };
3192 virtual void PreCallRecordGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
3193 virtual void PostCallRecordGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
3194#ifdef VK_USE_PLATFORM_WIN32_KHR
3195 virtual bool PreCallValidateImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { return false; };
3196 virtual void PreCallRecordImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {};
3197 virtual void PostCallRecordImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, VkResult result) {};
3198#endif
3199#ifdef VK_USE_PLATFORM_WIN32_KHR
3200 virtual bool PreCallValidateGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { return false; };
3201 virtual void PreCallRecordGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {};
3202 virtual void PostCallRecordGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, VkResult result) {};
3203#endif
3204 virtual bool PreCallValidateImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { return false; };
3205 virtual void PreCallRecordImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {};
3206 virtual void PostCallRecordImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo, VkResult result) {};
3207 virtual bool PreCallValidateGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { return false; };
3208 virtual void PreCallRecordGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {};
3209 virtual void PostCallRecordGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result) {};
3210 virtual bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { return false; };
3211 virtual void PreCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {};
3212 virtual void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities, VkResult result) {};
3213 virtual bool PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { return false; };
3214 virtual void PreCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) {};
3215 virtual void PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats, VkResult result) {};
3216 virtual bool PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) { return false; };
3217 virtual void PreCallRecordGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) {};
3218 virtual void PostCallRecordGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties, VkResult result) {};
3219 virtual bool PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) { return false; };
3220 virtual void PreCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) {};
3221 virtual void PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties, VkResult result) {};
3222 virtual bool PreCallValidateGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) { return false; };
3223 virtual void PreCallRecordGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) {};
3224 virtual void PostCallRecordGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties, VkResult result) {};
3225 virtual bool PreCallValidateGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) { return false; };
3226 virtual void PreCallRecordGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) {};
3227 virtual void PostCallRecordGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities, VkResult result) {};
3228 virtual bool PreCallValidateGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
3229 virtual void PreCallRecordGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3230 virtual void PostCallRecordGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3231 virtual bool PreCallValidateGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
3232 virtual void PreCallRecordGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3233 virtual void PostCallRecordGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3234 virtual bool PreCallValidateGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { return false; };
3235 virtual void PreCallRecordGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
3236 virtual void PostCallRecordGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
3237 virtual bool PreCallValidateCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return false; };
3238 virtual void PreCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {};
3239 virtual void PostCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result) {};
3240 virtual bool PreCallValidateDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { return false; };
3241 virtual void PreCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
3242 virtual void PostCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
3243 virtual bool PreCallValidateBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { return false; };
3244 virtual void PreCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {};
3245 virtual void PostCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult result) {};
3246 virtual bool PreCallValidateBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { return false; };
3247 virtual void PreCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {};
3248 virtual void PostCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult result) {};
3249 virtual bool PreCallValidateGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { return false; };
3250 virtual void PreCallRecordGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
3251 virtual void PostCallRecordGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
3252 virtual bool PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3253 virtual void PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3254 virtual void PostCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3255 virtual bool PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3256 virtual void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3257 virtual void PostCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3258 virtual bool PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { return false; };
3259 virtual void PreCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {};
3260 virtual void PostCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, VkResult result) {};
3261 virtual bool PreCallValidateDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { return false; };
3262 virtual void PreCallRecordDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {};
3263 virtual void PostCallRecordDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {};
3264 virtual bool PreCallValidateDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { return false; };
3265 virtual void PreCallRecordDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {};
3266 virtual void PostCallRecordDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {};
3267 virtual bool PreCallValidateDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { return false; };
3268 virtual void PreCallRecordDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {};
3269 virtual void PostCallRecordDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo, VkResult result) {};
3270 virtual bool PreCallValidateDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { return false; };
3271 virtual void PreCallRecordDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {};
3272 virtual void PostCallRecordDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo, VkResult result) {};
3273 virtual bool PreCallValidateCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { return false; };
3274 virtual void PreCallRecordCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3275 virtual void PostCallRecordCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3276 virtual bool PreCallValidateCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { return false; };
3277 virtual void PreCallRecordCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {};
3278 virtual void PostCallRecordCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {};
3279 virtual bool PreCallValidateCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { return false; };
3280 virtual void PreCallRecordCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3281 virtual void PostCallRecordCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3282 virtual bool PreCallValidateCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { return false; };
3283 virtual void PreCallRecordCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {};
3284 virtual void PostCallRecordCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {};
3285 virtual bool PreCallValidateCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { return false; };
3286 virtual void PreCallRecordCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3287 virtual void PostCallRecordCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3288 virtual bool PreCallValidateCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { return false; };
3289 virtual void PreCallRecordCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3290 virtual void PostCallRecordCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3291 virtual bool PreCallValidateCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { return false; };
3292 virtual void PreCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {};
3293 virtual void PostCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {};
3294 virtual bool PreCallValidateCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { return false; };
3295 virtual void PreCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {};
3296 virtual void PostCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {};
3297 virtual bool PreCallValidateCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { return false; };
3298 virtual void PreCallRecordCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {};
3299 virtual void PostCallRecordCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {};
3300 virtual bool PreCallValidateGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { return false; };
3301 virtual void PreCallRecordGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {};
3302 virtual void PostCallRecordGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {};
3303 virtual bool PreCallValidateCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3304 virtual void PreCallRecordCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3305 virtual void PostCallRecordCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3306 virtual bool PreCallValidateCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3307 virtual void PreCallRecordCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3308 virtual void PostCallRecordCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3309 virtual bool PreCallValidateGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { return false; };
3310 virtual void PreCallRecordGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {};
3311 virtual void PostCallRecordGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, VkResult result) {};
3312#ifdef VK_USE_PLATFORM_GGP
3313 virtual bool PreCallValidateCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3314 virtual void PreCallRecordCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3315 virtual void PostCallRecordCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3316#endif
3317 virtual bool PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { return false; };
3318 virtual void PreCallRecordGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {};
3319 virtual void PostCallRecordGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, VkResult result) {};
3320#ifdef VK_USE_PLATFORM_WIN32_KHR
3321 virtual bool PreCallValidateGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { return false; };
3322 virtual void PreCallRecordGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) {};
3323 virtual void PostCallRecordGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, VkResult result) {};
3324#endif
3325#ifdef VK_USE_PLATFORM_VI_NN
3326 virtual bool PreCallValidateCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3327 virtual void PreCallRecordCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3328 virtual void PostCallRecordCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3329#endif
3330 virtual bool PreCallValidateCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { return false; };
3331 virtual void PreCallRecordCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {};
3332 virtual void PostCallRecordCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {};
3333 virtual bool PreCallValidateCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) { return false; };
3334 virtual void PreCallRecordCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {};
3335 virtual void PostCallRecordCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {};
3336 virtual bool PreCallValidateCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) { return false; };
3337 virtual void PreCallRecordCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {};
3338 virtual void PostCallRecordCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {};
3339 virtual bool PreCallValidateCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) { return false; };
3340 virtual void PreCallRecordCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {};
3341 virtual void PostCallRecordCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {};
3342 virtual bool PreCallValidateCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) { return false; };
3343 virtual void PreCallRecordCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) {};
3344 virtual void PostCallRecordCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout, VkResult result) {};
3345 virtual bool PreCallValidateDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { return false; };
3346 virtual void PreCallRecordDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {};
3347 virtual void PostCallRecordDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {};
3348 virtual bool PreCallValidateCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) { return false; };
3349 virtual void PreCallRecordCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) {};
3350 virtual void PostCallRecordCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable, VkResult result) {};
3351 virtual bool PreCallValidateDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) { return false; };
3352 virtual void PreCallRecordDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) {};
3353 virtual void PostCallRecordDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) {};
3354 virtual bool PreCallValidateRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices) { return false; };
3355 virtual void PreCallRecordRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices) {};
3356 virtual void PostCallRecordRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, VkResult result) {};
3357 virtual bool PreCallValidateUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices) { return false; };
3358 virtual void PreCallRecordUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices) {};
3359 virtual void PostCallRecordUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, VkResult result) {};
3360 virtual bool PreCallValidateGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) { return false; };
3361 virtual void PreCallRecordGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) {};
3362 virtual void PostCallRecordGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) {};
3363 virtual bool PreCallValidateCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { return false; };
3364 virtual void PreCallRecordCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {};
3365 virtual void PostCallRecordCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {};
3366 virtual bool PreCallValidateReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { return false; };
3367 virtual void PreCallRecordReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {};
3368 virtual void PostCallRecordReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkResult result) {};
3369#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3370 virtual bool PreCallValidateAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { return false; };
3371 virtual void PreCallRecordAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) {};
3372 virtual void PostCallRecordAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display, VkResult result) {};
3373#endif
3374#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3375 virtual bool PreCallValidateGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) { return false; };
3376 virtual void PreCallRecordGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) {};
3377 virtual void PostCallRecordGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay, VkResult result) {};
3378#endif
3379 virtual bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { return false; };
3380 virtual void PreCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {};
3381 virtual void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities, VkResult result) {};
3382 virtual bool PreCallValidateDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { return false; };
3383 virtual void PreCallRecordDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {};
3384 virtual void PostCallRecordDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo, VkResult result) {};
3385 virtual bool PreCallValidateRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { return false; };
3386 virtual void PreCallRecordRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {};
3387 virtual void PostCallRecordRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult result) {};
3388 virtual bool PreCallValidateRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { return false; };
3389 virtual void PreCallRecordRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {};
3390 virtual void PostCallRecordRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult result) {};
3391 virtual bool PreCallValidateGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { return false; };
3392 virtual void PreCallRecordGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) {};
3393 virtual void PostCallRecordGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, VkResult result) {};
3394 virtual bool PreCallValidateGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { return false; };
3395 virtual void PreCallRecordGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {};
3396 virtual void PostCallRecordGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, VkResult result) {};
3397 virtual bool PreCallValidateGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { return false; };
3398 virtual void PreCallRecordGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {};
3399 virtual void PostCallRecordGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings, VkResult result) {};
3400 virtual bool PreCallValidateCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { return false; };
3401 virtual void PreCallRecordCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {};
3402 virtual void PostCallRecordCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {};
3403 virtual bool PreCallValidateSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { return false; };
3404 virtual void PreCallRecordSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {};
3405 virtual void PostCallRecordSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {};
3406#ifdef VK_USE_PLATFORM_IOS_MVK
3407 virtual bool PreCallValidateCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3408 virtual void PreCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3409 virtual void PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3410#endif
3411#ifdef VK_USE_PLATFORM_MACOS_MVK
3412 virtual bool PreCallValidateCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3413 virtual void PreCallRecordCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3414 virtual void PostCallRecordCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3415#endif
3416 virtual bool PreCallValidateSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { return false; };
3417 virtual void PreCallRecordSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {};
3418 virtual void PostCallRecordSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo, VkResult result) {};
3419 virtual bool PreCallValidateSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { return false; };
3420 virtual void PreCallRecordSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {};
3421 virtual void PostCallRecordSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo, VkResult result) {};
3422 virtual bool PreCallValidateQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3423 virtual void PreCallRecordQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3424 virtual void PostCallRecordQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3425 virtual bool PreCallValidateQueueEndDebugUtilsLabelEXT(VkQueue queue) { return false; };
3426 virtual void PreCallRecordQueueEndDebugUtilsLabelEXT(VkQueue queue) {};
3427 virtual void PostCallRecordQueueEndDebugUtilsLabelEXT(VkQueue queue) {};
3428 virtual bool PreCallValidateQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3429 virtual void PreCallRecordQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3430 virtual void PostCallRecordQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3431 virtual bool PreCallValidateCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3432 virtual void PreCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3433 virtual void PostCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3434 virtual bool PreCallValidateCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { return false; };
3435 virtual void PreCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {};
3436 virtual void PostCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {};
3437 virtual bool PreCallValidateCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3438 virtual void PreCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3439 virtual void PostCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3440 virtual bool PreCallValidateCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { return false; };
3441 virtual void PreCallRecordCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) {};
3442 virtual void PostCallRecordCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger, VkResult result) {};
3443 virtual bool PreCallValidateDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { return false; };
3444 virtual void PreCallRecordDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {};
3445 virtual void PostCallRecordDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {};
3446 virtual bool PreCallValidateSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { return false; };
3447 virtual void PreCallRecordSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {};
3448 virtual void PostCallRecordSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {};
3449#ifdef VK_USE_PLATFORM_ANDROID_KHR
3450 virtual bool PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { return false; };
3451 virtual void PreCallRecordGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) {};
3452 virtual void PostCallRecordGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties, VkResult result) {};
3453#endif
3454#ifdef VK_USE_PLATFORM_ANDROID_KHR
3455 virtual bool PreCallValidateGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { return false; };
3456 virtual void PreCallRecordGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) {};
3457 virtual void PostCallRecordGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, VkResult result) {};
3458#endif
3459 virtual bool PreCallValidateCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { return false; };
3460 virtual void PreCallRecordCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {};
3461 virtual void PostCallRecordCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {};
3462 virtual bool PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) { return false; };
3463 virtual void PreCallRecordGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {};
3464 virtual void PostCallRecordGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {};
3465 virtual bool PreCallValidateGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { return false; };
3466 virtual void PreCallRecordGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {};
3467 virtual void PostCallRecordGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, VkResult result) {};
3468 virtual bool PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { return false; };
3469 virtual void PreCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {};
3470 virtual void PostCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {};
3471 virtual bool PreCallValidateCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { return false; };
3472 virtual void PreCallRecordCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {};
3473 virtual void PostCallRecordCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {};
3474 virtual bool PreCallValidateCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { return false; };
3475 virtual void PreCallRecordCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {};
3476 virtual void PostCallRecordCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {};
3477 virtual bool PreCallValidateCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { return false; };
3478 virtual void PreCallRecordCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) {};
3479 virtual void PostCallRecordCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure, VkResult result) {};
3480 virtual bool PreCallValidateDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { return false; };
3481 virtual void PreCallRecordDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) {};
3482 virtual void PostCallRecordDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) {};
3483 virtual bool PreCallValidateGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { return false; };
3484 virtual void PreCallRecordGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) {};
3485 virtual void PostCallRecordGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) {};
3486 virtual bool PreCallValidateBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { return false; };
3487 virtual void PreCallRecordBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {};
3488 virtual void PostCallRecordBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, VkResult result) {};
3489 virtual bool PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { return false; };
3490 virtual void PreCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {};
3491 virtual void PostCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {};
3492 virtual bool PreCallValidateCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) { return false; };
3493 virtual void PreCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) {};
3494 virtual void PostCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) {};
3495 virtual bool 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) { return false; };
3496 virtual void PreCallRecordCmdTraceRaysNV(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) {};
3497 virtual void PostCallRecordCmdTraceRaysNV(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) {};
3498 virtual bool PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; };
3499 virtual void PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {};
3500 virtual void PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {};
3501 virtual bool PreCallValidateGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { return false; };
3502 virtual void PreCallRecordGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {};
3503 virtual void PostCallRecordGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult result) {};
3504 virtual bool PreCallValidateGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { return false; };
3505 virtual void PreCallRecordGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) {};
3506 virtual void PostCallRecordGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, VkResult result) {};
3507 virtual bool PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { return false; };
3508 virtual void PreCallRecordCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {};
3509 virtual void PostCallRecordCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {};
3510 virtual bool PreCallValidateCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) { return false; };
3511 virtual void PreCallRecordCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) {};
3512 virtual void PostCallRecordCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader, VkResult result) {};
3513 virtual bool PreCallValidateGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { return false; };
3514 virtual void PreCallRecordGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {};
3515 virtual void PostCallRecordGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, VkResult result) {};
3516 virtual bool PreCallValidateCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { return false; };
3517 virtual void PreCallRecordCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {};
3518 virtual void PostCallRecordCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {};
3519 virtual bool PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) { return false; };
3520 virtual void PreCallRecordGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) {};
3521 virtual void PostCallRecordGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains, VkResult result) {};
3522 virtual bool PreCallValidateGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { return false; };
3523 virtual void PreCallRecordGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {};
3524 virtual void PostCallRecordGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, VkResult result) {};
3525 virtual bool PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { return false; };
3526 virtual void PreCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {};
3527 virtual void PostCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {};
3528 virtual bool PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { return false; };
3529 virtual void PreCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
3530 virtual void PostCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
3531 virtual bool PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3532 virtual void PreCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3533 virtual void PostCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3534 virtual bool PreCallValidateCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { return false; };
3535 virtual void PreCallRecordCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {};
3536 virtual void PostCallRecordCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {};
3537 virtual bool PreCallValidateCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { return false; };
3538 virtual void PreCallRecordCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {};
3539 virtual void PostCallRecordCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {};
3540 virtual bool PreCallValidateGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { return false; };
3541 virtual void PreCallRecordGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {};
3542 virtual void PostCallRecordGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {};
3543 virtual bool PreCallValidateInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { return false; };
3544 virtual void PreCallRecordInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {};
3545 virtual void PostCallRecordInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, VkResult result) {};
3546 virtual bool PreCallValidateUninitializePerformanceApiINTEL(VkDevice device) { return false; };
3547 virtual void PreCallRecordUninitializePerformanceApiINTEL(VkDevice device) {};
3548 virtual void PostCallRecordUninitializePerformanceApiINTEL(VkDevice device) {};
3549 virtual bool PreCallValidateCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { return false; };
3550 virtual void PreCallRecordCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {};
3551 virtual void PostCallRecordCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo, VkResult result) {};
3552 virtual bool PreCallValidateCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { return false; };
3553 virtual void PreCallRecordCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {};
3554 virtual void PostCallRecordCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo, VkResult result) {};
3555 virtual bool PreCallValidateCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { return false; };
3556 virtual void PreCallRecordCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {};
3557 virtual void PostCallRecordCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo, VkResult result) {};
3558 virtual bool PreCallValidateAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { return false; };
3559 virtual void PreCallRecordAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) {};
3560 virtual void PostCallRecordAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration, VkResult result) {};
3561 virtual bool PreCallValidateReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) { return false; };
3562 virtual void PreCallRecordReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) {};
3563 virtual void PostCallRecordReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration, VkResult result) {};
3564 virtual bool PreCallValidateQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) { return false; };
3565 virtual void PreCallRecordQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) {};
3566 virtual void PostCallRecordQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration, VkResult result) {};
3567 virtual bool PreCallValidateGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { return false; };
3568 virtual void PreCallRecordGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) {};
3569 virtual void PostCallRecordGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue, VkResult result) {};
3570 virtual bool PreCallValidateSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { return false; };
3571 virtual void PreCallRecordSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {};
3572 virtual void PostCallRecordSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {};
3573#ifdef VK_USE_PLATFORM_FUCHSIA
3574 virtual bool PreCallValidateCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3575 virtual void PreCallRecordCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3576 virtual void PostCallRecordCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3577#endif
3578#ifdef VK_USE_PLATFORM_METAL_EXT
3579 virtual bool PreCallValidateCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3580 virtual void PreCallRecordCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3581 virtual void PostCallRecordCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3582#endif
3583 virtual bool PreCallValidateGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) { return false; };
3584 virtual void PreCallRecordGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) {};
3585 virtual void PostCallRecordGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) {};
3586 virtual bool PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) { return false; };
3587 virtual void PreCallRecordGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) {};
3588 virtual void PostCallRecordGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties, VkResult result) {};
3589 virtual bool PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { return false; };
3590 virtual void PreCallRecordGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) {};
3591 virtual void PostCallRecordGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations, VkResult result) {};
3592#ifdef VK_USE_PLATFORM_WIN32_KHR
3593 virtual bool PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { return false; };
3594 virtual void PreCallRecordGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {};
3595 virtual void PostCallRecordGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, VkResult result) {};
3596#endif
3597#ifdef VK_USE_PLATFORM_WIN32_KHR
3598 virtual bool PreCallValidateAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { return false; };
3599 virtual void PreCallRecordAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {};
3600 virtual void PostCallRecordAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain, VkResult result) {};
3601#endif
3602#ifdef VK_USE_PLATFORM_WIN32_KHR
3603 virtual bool PreCallValidateReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { return false; };
3604 virtual void PreCallRecordReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {};
3605 virtual void PostCallRecordReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain, VkResult result) {};
3606#endif
3607#ifdef VK_USE_PLATFORM_WIN32_KHR
3608 virtual bool PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { return false; };
3609 virtual void PreCallRecordGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) {};
3610 virtual void PostCallRecordGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes, VkResult result) {};
3611#endif
3612 virtual bool PreCallValidateCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3613 virtual void PreCallRecordCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3614 virtual void PostCallRecordCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3615 virtual bool PreCallValidateResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { return false; };
3616 virtual void PreCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
3617 virtual void PostCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
3618
3619 virtual VkResult CoreLayerCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { return VK_SUCCESS; };
3620 virtual void CoreLayerDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) {};
3621 virtual VkResult CoreLayerMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { return VK_SUCCESS; };
3622 virtual VkResult CoreLayerGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { return VK_SUCCESS; };
3623
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame]3624 // Allow additional state parameter for CreateGraphicsPipelines
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3625 virtual bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state) {
3626 return PreCallValidateCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3627 };
3628 virtual void PreCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state) {
3629 PreCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3630 };
3631 virtual void PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* cgpl_state) {
3632 PostCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
3633 };
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame]3634
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3635 // Allow additional state parameter for CreateComputePipelines
3636 virtual bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state) {
3637 return PreCallValidateCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3638 };
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame]3639 virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
3640 PreCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3641 };
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3642 virtual void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
3643 PostCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
3644 };
3645
3646 // Allow additional state parameter for CreateRayTracingPipelinesNV
3647 virtual bool PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state) {
3648 return PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3649 };
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame]3650 virtual void PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
3651 PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3652 };
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3653 virtual void PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
3654 PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
3655 };
3656
3657 // Allow modification of a down-chain parameter for CreatePipelineLayout
3658 virtual void PreCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, void *cpl_state) {
3659 PreCallRecordCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
3660 };
3661
3662 // Enable the CreateShaderModule API to take an extra argument for state preservation and paramter modification
3663 virtual bool PreCallValidateCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, void* csm_state) {
3664 return PreCallValidateCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
3665 };
3666 virtual void PreCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, void* csm_state) {
3667 PreCallRecordCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
3668 };
3669 virtual void PostCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult result, void* csm_state) {
3670 PostCallRecordCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule, result);
3671 };
3672
3673 // Allow AllocateDescriptorSets to use some local stack storage for performance purposes
3674 virtual bool PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, void* ads_state) {
3675 return PreCallValidateAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
3676 };
3677 virtual void PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, VkResult result, void* ads_state) {
3678 PostCallRecordAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets, result);
3679 };
3680
3681 // Modify a parameter to CreateDevice
3682 virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, std::unique_ptr<safe_VkDeviceCreateInfo> &modified_create_info) {
3683 PreCallRecordCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
3684 };
3685};
3686
3687extern std::unordered_map<void*, ValidationObject*> layer_data_map;