Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 67407e74829b1c034541192f7ad8ed1004220a72 / . / layers / generated / chassis.h
blob: 30ac005897491212e1c8e12d20dc3f64d6745761 [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,
2355} ValidationCheckDisables;
2356
2357
2358// CHECK_DISABLED struct is a container for bools that can block validation checks from being performed.
2359// These bools are all "false" by default meaning that all checks are enabled. Enum values can be specified
2360// via the vk_layer_setting.txt config file or at CreateInstance time via the VK_EXT_validation_features extension
2361// that can selectively disable checks.
2362struct CHECK_DISABLED {
2363 bool command_buffer_state; // Skip command buffer state validation
2364 bool object_in_use; // Skip all object in_use checking
2365 bool idle_descriptor_set; // Skip check to verify that descriptor set is not in-use
2366 bool push_constant_range; // Skip push constant range checks
2367 bool query_validation; // Disable all core validation query-related checks
2368 bool object_tracking; // Disable object lifetime validation
2369 bool core_checks; // Disable core validation checks
2370 bool thread_safety; // Disable thread safety validation
2371 bool stateless_checks; // Disable stateless validation checks
2372 bool handle_wrapping; // Disable unique handles/handle wrapping
2373 bool shader_validation; // Skip validation for shaders
2374
2375 void SetAll(bool value) { std::fill(&command_buffer_state, &shader_validation + 1, value); }
2376};
2377
2378struct CHECK_ENABLED {
2379 bool gpu_validation;
2380 bool gpu_validation_reserve_binding_slot;
2381
2382 void SetAll(bool value) { std::fill(&gpu_validation, &gpu_validation_reserve_binding_slot + 1, value); }
2383};
2384
2385// Layer chassis validation object base class definition
2386class ValidationObject {
2387 public:
2388 uint32_t api_version;
2389 debug_report_data* report_data = nullptr;
2390 std::vector<VkDebugReportCallbackEXT> logging_callback;
2391 std::vector<VkDebugUtilsMessengerEXT> logging_messenger;
2392
2393 VkLayerInstanceDispatchTable instance_dispatch_table;
2394 VkLayerDispatchTable device_dispatch_table;
2395
2396 InstanceExtensions instance_extensions;
2397 DeviceExtensions device_extensions = {};
2398 CHECK_DISABLED disabled = {};
2399 CHECK_ENABLED enabled = {};
2400
2401 VkInstance instance = VK_NULL_HANDLE;
2402 VkPhysicalDevice physical_device = VK_NULL_HANDLE;
2403 VkDevice device = VK_NULL_HANDLE;
2404 LAYER_PHYS_DEV_PROPERTIES phys_dev_properties = {};
2405
2406 std::vector<ValidationObject*> object_dispatch;
2407 LayerObjectTypeId container_type;
2408
2409 std::string layer_name = "CHASSIS";
2410
2411 // Constructor
2412 ValidationObject(){};
2413 // Destructor
2414 virtual ~ValidationObject() {};
2415
2416 std::mutex validation_object_mutex;
2417 virtual std::unique_lock<std::mutex> write_lock() {
2418 return std::unique_lock<std::mutex>(validation_object_mutex);
2419 }
2420
2421 ValidationObject* GetValidationObject(std::vector<ValidationObject*>& object_dispatch, LayerObjectTypeId object_type) {
2422 for (auto validation_object : object_dispatch) {
2423 if (validation_object->container_type == object_type) {
2424 return validation_object;
2425 }
2426 }
2427 return nullptr;
2428 };
2429
2430 // Handle Wrapping Data
2431 // Reverse map display handles
2432 std::unordered_map<VkDisplayKHR, uint64_t> display_id_reverse_mapping;
2433 // Wrapping Descriptor Template Update structures requires access to the template createinfo structs
2434 std::unordered_map<uint64_t, std::unique_ptr<TEMPLATE_STATE>> desc_template_createinfo_map;
2435 struct SubpassesUsageStates {
2436 std::unordered_set<uint32_t> subpasses_using_color_attachment;
2437 std::unordered_set<uint32_t> subpasses_using_depthstencil_attachment;
2438 };
2439 // Uses unwrapped handles
2440 std::unordered_map<VkRenderPass, SubpassesUsageStates> renderpasses_states;
2441 // Map of wrapped swapchain handles to arrays of wrapped swapchain image IDs
2442 // Each swapchain has an immutable list of wrapped swapchain image IDs -- always return these IDs if they exist
2443 std::unordered_map<VkSwapchainKHR, std::vector<VkImage>> swapchain_wrapped_image_handle_map;
2444 // Map of wrapped descriptor pools to set of wrapped descriptor sets allocated from each pool
2445 std::unordered_map<VkDescriptorPool, std::unordered_set<VkDescriptorSet>> pool_descriptor_sets_map;
2446
2447
2448 // Unwrap a handle. Must hold lock.
2449 template <typename HandleType>
2450 HandleType Unwrap(HandleType wrappedHandle) {
2451 // TODO: don't use operator[] here.
2452 return (HandleType)unique_id_mapping[reinterpret_cast<uint64_t const &>(wrappedHandle)];
2453 }
2454
2455 // Wrap a newly created handle with a new unique ID, and return the new ID -- must hold lock.
2456 template <typename HandleType>
2457 HandleType WrapNew(HandleType newlyCreatedHandle) {
2458 auto unique_id = global_unique_id++;
2459 unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
2460 return (HandleType)unique_id;
2461 }
2462
2463 // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup. Must hold lock.
2464 VkDisplayKHR WrapDisplay(VkDisplayKHR newlyCreatedHandle, ValidationObject *map_data) {
2465 auto unique_id = global_unique_id++;
2466 unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
2467 map_data->display_id_reverse_mapping[newlyCreatedHandle] = unique_id;
2468 return (VkDisplayKHR)unique_id;
2469 }
2470
2471 // VkDisplayKHR objects don't have a single point of creation, so we need to see if one already exists in the map before
2472 // creating another. Must hold lock.
2473 VkDisplayKHR MaybeWrapDisplay(VkDisplayKHR handle, ValidationObject *map_data) {
2474 // See if this display is already known
2475 auto it = map_data->display_id_reverse_mapping.find(handle);
2476 if (it != map_data->display_id_reverse_mapping.end()) return (VkDisplayKHR)it->second;
2477 // Unknown, so wrap
2478 return WrapDisplay(handle, map_data);
2479 }
2480
2481 // Pre/post hook point declarations
2482 virtual bool PreCallValidateCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { return false; };
2483 virtual void PreCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {};
2484 virtual void PostCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, VkResult result) {};
2485 virtual bool PreCallValidateDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { return false; };
2486 virtual void PreCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {};
2487 virtual void PostCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {};
2488 virtual bool PreCallValidateEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { return false; };
2489 virtual void PreCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {};
2490 virtual void PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, VkResult result) {};
2491 virtual bool PreCallValidateGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { return false; };
2492 virtual void PreCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {};
2493 virtual void PostCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {};
2494 virtual bool PreCallValidateGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { return false; };
2495 virtual void PreCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {};
2496 virtual void PostCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {};
2497 virtual bool PreCallValidateGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { return false; };
2498 virtual void PreCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {};
2499 virtual void PostCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, VkResult result) {};
2500 virtual bool PreCallValidateGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { return false; };
2501 virtual void PreCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {};
2502 virtual void PostCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {};
2503 virtual bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { return false; };
2504 virtual void PreCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {};
2505 virtual void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {};
2506 virtual bool PreCallValidateGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { return false; };
2507 virtual void PreCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {};
2508 virtual void PostCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {};
2509 virtual bool PreCallValidateGetInstanceProcAddr(VkInstance instance, const char* pName) { return false; };
2510 virtual void PreCallRecordGetInstanceProcAddr(VkInstance instance, const char* pName) {};
2511 virtual void PostCallRecordGetInstanceProcAddr(VkInstance instance, const char* pName) {};
2512 virtual bool PreCallValidateGetDeviceProcAddr(VkDevice device, const char* pName) { return false; };
2513 virtual void PreCallRecordGetDeviceProcAddr(VkDevice device, const char* pName) {};
2514 virtual void PostCallRecordGetDeviceProcAddr(VkDevice device, const char* pName) {};
2515 virtual bool PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { return false; };
2516 virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {};
2517 virtual void PostCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, VkResult result) {};
2518 virtual bool PreCallValidateDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { return false; };
2519 virtual void PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {};
2520 virtual void PostCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {};
2521 virtual bool PreCallValidateEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { return false; };
2522 virtual void PreCallRecordEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {};
2523 virtual void PostCallRecordEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult result) {};
2524 virtual bool PreCallValidateEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { return false; };
2525 virtual void PreCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {};
2526 virtual void PostCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult result) {};
2527 virtual bool PreCallValidateEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return false; };
2528 virtual void PreCallRecordEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {};
2529 virtual void PostCallRecordEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult result) {};
2530 virtual bool PreCallValidateEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return false; };
2531 virtual void PreCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {};
2532 virtual void PostCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult result) {};
2533 virtual bool PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { return false; };
2534 virtual void PreCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {};
2535 virtual void PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {};
2536 virtual bool PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { return false; };
2537 virtual void PreCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {};
2538 virtual void PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, VkResult result) {};
2539 virtual bool PreCallValidateQueueWaitIdle(VkQueue queue) { return false; };
2540 virtual void PreCallRecordQueueWaitIdle(VkQueue queue) {};
2541 virtual void PostCallRecordQueueWaitIdle(VkQueue queue, VkResult result) {};
2542 virtual bool PreCallValidateDeviceWaitIdle(VkDevice device) { return false; };
2543 virtual void PreCallRecordDeviceWaitIdle(VkDevice device) {};
2544 virtual void PostCallRecordDeviceWaitIdle(VkDevice device, VkResult result) {};
2545 virtual bool PreCallValidateAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { return false; };
2546 virtual void PreCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {};
2547 virtual void PostCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, VkResult result) {};
2548 virtual bool PreCallValidateFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { return false; };
2549 virtual void PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {};
2550 virtual void PostCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {};
2551 virtual bool PreCallValidateMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { return false; };
2552 virtual void PreCallRecordMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {};
2553 virtual void PostCallRecordMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData, VkResult result) {};
2554 virtual bool PreCallValidateUnmapMemory(VkDevice device, VkDeviceMemory memory) { return false; };
2555 virtual void PreCallRecordUnmapMemory(VkDevice device, VkDeviceMemory memory) {};
2556 virtual void PostCallRecordUnmapMemory(VkDevice device, VkDeviceMemory memory) {};
2557 virtual bool PreCallValidateFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { return false; };
2558 virtual void PreCallRecordFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {};
2559 virtual void PostCallRecordFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult result) {};
2560 virtual bool PreCallValidateInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { return false; };
2561 virtual void PreCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {};
2562 virtual void PostCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult result) {};
2563 virtual bool PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { return false; };
2564 virtual void PreCallRecordGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {};
2565 virtual void PostCallRecordGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {};
2566 virtual bool PreCallValidateBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { return false; };
2567 virtual void PreCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {};
2568 virtual void PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult result) {};
2569 virtual bool PreCallValidateBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { return false; };
2570 virtual void PreCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {};
2571 virtual void PostCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult result) {};
2572 virtual bool PreCallValidateGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { return false; };
2573 virtual void PreCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {};
2574 virtual void PostCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {};
2575 virtual bool PreCallValidateGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { return false; };
2576 virtual void PreCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {};
2577 virtual void PostCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {};
2578 virtual bool PreCallValidateGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { return false; };
2579 virtual void PreCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {};
2580 virtual void PostCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {};
2581 virtual bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { return false; };
2582 virtual void PreCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {};
2583 virtual void PostCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {};
2584 virtual bool PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { return false; };
2585 virtual void PreCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {};
2586 virtual void PostCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, VkResult result) {};
2587 virtual bool PreCallValidateCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { return false; };
2588 virtual void PreCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {};
2589 virtual void PostCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult result) {};
2590 virtual bool PreCallValidateDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { return false; };
2591 virtual void PreCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {};
2592 virtual void PostCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {};
2593 virtual bool PreCallValidateResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { return false; };
2594 virtual void PreCallRecordResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {};
2595 virtual void PostCallRecordResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkResult result) {};
2596 virtual bool PreCallValidateGetFenceStatus(VkDevice device, VkFence fence) { return false; };
2597 virtual void PreCallRecordGetFenceStatus(VkDevice device, VkFence fence) {};
2598 virtual void PostCallRecordGetFenceStatus(VkDevice device, VkFence fence, VkResult result) {};
2599 virtual bool PreCallValidateWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { return false; };
2600 virtual void PreCallRecordWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {};
2601 virtual void PostCallRecordWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, VkResult result) {};
2602 virtual bool PreCallValidateCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { return false; };
2603 virtual void PreCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {};
2604 virtual void PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, VkResult result) {};
2605 virtual bool PreCallValidateDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { return false; };
2606 virtual void PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {};
2607 virtual void PostCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {};
2608 virtual bool PreCallValidateCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { return false; };
2609 virtual void PreCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {};
2610 virtual void PostCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, VkResult result) {};
2611 virtual bool PreCallValidateDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { return false; };
2612 virtual void PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {};
2613 virtual void PostCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {};
2614 virtual bool PreCallValidateGetEventStatus(VkDevice device, VkEvent event) { return false; };
2615 virtual void PreCallRecordGetEventStatus(VkDevice device, VkEvent event) {};
2616 virtual void PostCallRecordGetEventStatus(VkDevice device, VkEvent event, VkResult result) {};
2617 virtual bool PreCallValidateSetEvent(VkDevice device, VkEvent event) { return false; };
2618 virtual void PreCallRecordSetEvent(VkDevice device, VkEvent event) {};
2619 virtual void PostCallRecordSetEvent(VkDevice device, VkEvent event, VkResult result) {};
2620 virtual bool PreCallValidateResetEvent(VkDevice device, VkEvent event) { return false; };
2621 virtual void PreCallRecordResetEvent(VkDevice device, VkEvent event) {};
2622 virtual void PostCallRecordResetEvent(VkDevice device, VkEvent event, VkResult result) {};
2623 virtual bool PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { return false; };
2624 virtual void PreCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {};
2625 virtual void PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, VkResult result) {};
2626 virtual bool PreCallValidateDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { return false; };
2627 virtual void PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {};
2628 virtual void PostCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {};
2629 virtual bool PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { return false; };
2630 virtual void PreCallRecordGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {};
2631 virtual void PostCallRecordGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, VkResult result) {};
2632 virtual bool PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { return false; };
2633 virtual void PreCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {};
2634 virtual void PostCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, VkResult result) {};
2635 virtual bool PreCallValidateDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { return false; };
2636 virtual void PreCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {};
2637 virtual void PostCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {};
2638 virtual bool PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { return false; };
2639 virtual void PreCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {};
2640 virtual void PostCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, VkResult result) {};
2641 virtual bool PreCallValidateDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { return false; };
2642 virtual void PreCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {};
2643 virtual void PostCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {};
2644 virtual bool PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { return false; };
2645 virtual void PreCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {};
2646 virtual void PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, VkResult result) {};
2647 virtual bool PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { return false; };
2648 virtual void PreCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {};
2649 virtual void PostCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {};
2650 virtual bool PreCallValidateGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { return false; };
2651 virtual void PreCallRecordGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {};
2652 virtual void PostCallRecordGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {};
2653 virtual bool PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { return false; };
2654 virtual void PreCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {};
2655 virtual void PostCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, VkResult result) {};
2656 virtual bool PreCallValidateDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { return false; };
2657 virtual void PreCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {};
2658 virtual void PostCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {};
2659 virtual bool PreCallValidateCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { return false; };
2660 virtual void PreCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {};
2661 virtual void PostCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult result) {};
2662 virtual bool PreCallValidateDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { return false; };
2663 virtual void PreCallRecordDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {};
2664 virtual void PostCallRecordDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {};
2665 virtual bool PreCallValidateCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { return false; };
2666 virtual void PreCallRecordCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {};
2667 virtual void PostCallRecordCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, VkResult result) {};
2668 virtual bool PreCallValidateDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { return false; };
2669 virtual void PreCallRecordDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {};
2670 virtual void PostCallRecordDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {};
2671 virtual bool PreCallValidateGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { return false; };
2672 virtual void PreCallRecordGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {};
2673 virtual void PostCallRecordGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, VkResult result) {};
2674 virtual bool PreCallValidateMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { return false; };
2675 virtual void PreCallRecordMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {};
2676 virtual void PostCallRecordMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, VkResult result) {};
2677 virtual bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; };
2678 virtual void PreCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {};
2679 virtual void PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {};
2680 virtual bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; };
2681 virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {};
2682 virtual void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {};
2683 virtual bool PreCallValidateDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { return false; };
2684 virtual void PreCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {};
2685 virtual void PostCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {};
2686 virtual bool PreCallValidateCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { return false; };
2687 virtual void PreCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {};
2688 virtual void PostCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, VkResult result) {};
2689 virtual bool PreCallValidateDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { return false; };
2690 virtual void PreCallRecordDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {};
2691 virtual void PostCallRecordDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {};
2692 virtual bool PreCallValidateCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { return false; };
2693 virtual void PreCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {};
2694 virtual void PostCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, VkResult result) {};
2695 virtual bool PreCallValidateDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { return false; };
2696 virtual void PreCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {};
2697 virtual void PostCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {};
2698 virtual bool PreCallValidateCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { return false; };
2699 virtual void PreCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {};
2700 virtual void PostCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, VkResult result) {};
2701 virtual bool PreCallValidateDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { return false; };
2702 virtual void PreCallRecordDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {};
2703 virtual void PostCallRecordDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {};
2704 virtual bool PreCallValidateCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { return false; };
2705 virtual void PreCallRecordCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {};
2706 virtual void PostCallRecordCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, VkResult result) {};
2707 virtual bool PreCallValidateDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { return false; };
2708 virtual void PreCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {};
2709 virtual void PostCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {};
2710 virtual bool PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { return false; };
2711 virtual void PreCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {};
2712 virtual void PostCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, VkResult result) {};
2713 virtual bool PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { return false; };
2714 virtual void PreCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {};
2715 virtual void PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, VkResult result) {};
2716 virtual bool PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { return false; };
2717 virtual void PreCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {};
2718 virtual void PostCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, VkResult result) {};
2719 virtual bool PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { return false; };
2720 virtual void PreCallRecordUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {};
2721 virtual void PostCallRecordUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {};
2722 virtual bool PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { return false; };
2723 virtual void PreCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {};
2724 virtual void PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, VkResult result) {};
2725 virtual bool PreCallValidateDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { return false; };
2726 virtual void PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {};
2727 virtual void PostCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {};
2728 virtual bool PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { return false; };
2729 virtual void PreCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {};
2730 virtual void PostCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result) {};
2731 virtual bool PreCallValidateDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { return false; };
2732 virtual void PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {};
2733 virtual void PostCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {};
2734 virtual bool PreCallValidateGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { return false; };
2735 virtual void PreCallRecordGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {};
2736 virtual void PostCallRecordGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {};
2737 virtual bool PreCallValidateCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { return false; };
2738 virtual void PreCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {};
2739 virtual void PostCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, VkResult result) {};
2740 virtual bool PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { return false; };
2741 virtual void PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {};
2742 virtual void PostCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {};
2743 virtual bool PreCallValidateResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { return false; };
2744 virtual void PreCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {};
2745 virtual void PostCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, VkResult result) {};
2746 virtual bool PreCallValidateAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { return false; };
2747 virtual void PreCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {};
2748 virtual void PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, VkResult result) {};
2749 virtual bool PreCallValidateFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { return false; };
2750 virtual void PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2751 virtual void PostCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2752 virtual bool PreCallValidateBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { return false; };
2753 virtual void PreCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {};
2754 virtual void PostCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, VkResult result) {};
2755 virtual bool PreCallValidateEndCommandBuffer(VkCommandBuffer commandBuffer) { return false; };
2756 virtual void PreCallRecordEndCommandBuffer(VkCommandBuffer commandBuffer) {};
2757 virtual void PostCallRecordEndCommandBuffer(VkCommandBuffer commandBuffer, VkResult result) {};
2758 virtual bool PreCallValidateResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { return false; };
2759 virtual void PreCallRecordResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {};
2760 virtual void PostCallRecordResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, VkResult result) {};
2761 virtual bool PreCallValidateCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { return false; };
2762 virtual void PreCallRecordCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {};
2763 virtual void PostCallRecordCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {};
2764 virtual bool PreCallValidateCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { return false; };
2765 virtual void PreCallRecordCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {};
2766 virtual void PostCallRecordCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {};
2767 virtual bool PreCallValidateCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { return false; };
2768 virtual void PreCallRecordCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {};
2769 virtual void PostCallRecordCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {};
2770 virtual bool PreCallValidateCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { return false; };
2771 virtual void PreCallRecordCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {};
2772 virtual void PostCallRecordCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {};
2773 virtual bool PreCallValidateCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { return false; };
2774 virtual void PreCallRecordCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {};
2775 virtual void PostCallRecordCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {};
2776 virtual bool PreCallValidateCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { return false; };
2777 virtual void PreCallRecordCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {};
2778 virtual void PostCallRecordCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {};
2779 virtual bool PreCallValidateCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { return false; };
2780 virtual void PreCallRecordCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {};
2781 virtual void PostCallRecordCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {};
2782 virtual bool PreCallValidateCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { return false; };
2783 virtual void PreCallRecordCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {};
2784 virtual void PostCallRecordCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {};
2785 virtual bool PreCallValidateCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { return false; };
2786 virtual void PreCallRecordCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {};
2787 virtual void PostCallRecordCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {};
2788 virtual bool PreCallValidateCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { return false; };
2789 virtual void PreCallRecordCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {};
2790 virtual void PostCallRecordCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {};
2791 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; };
2792 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) {};
2793 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) {};
2794 virtual bool PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { return false; };
2795 virtual void PreCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {};
2796 virtual void PostCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {};
2797 virtual bool PreCallValidateCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { return false; };
2798 virtual void PreCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {};
2799 virtual void PostCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {};
2800 virtual bool PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { return false; };
2801 virtual void PreCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {};
2802 virtual void PostCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {};
2803 virtual bool PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { return false; };
2804 virtual void PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {};
2805 virtual void PostCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {};
2806 virtual bool PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { return false; };
2807 virtual void PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2808 virtual void PostCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2809 virtual bool PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { return false; };
2810 virtual void PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2811 virtual void PostCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
2812 virtual bool PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { return false; };
2813 virtual void PreCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2814 virtual void PostCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2815 virtual bool PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { return false; };
2816 virtual void PreCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {};
2817 virtual void PostCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {};
2818 virtual bool PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { return false; };
2819 virtual void PreCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {};
2820 virtual void PostCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {};
2821 virtual bool PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { return false; };
2822 virtual void PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {};
2823 virtual void PostCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {};
2824 virtual bool PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { return false; };
2825 virtual void PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {};
2826 virtual void PostCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {};
2827 virtual bool PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { return false; };
2828 virtual void PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2829 virtual void PostCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2830 virtual bool PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { return false; };
2831 virtual void PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2832 virtual void PostCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {};
2833 virtual bool PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { return false; };
2834 virtual void PreCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {};
2835 virtual void PostCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {};
2836 virtual bool PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { return false; };
2837 virtual void PreCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {};
2838 virtual void PostCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {};
2839 virtual bool PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { return false; };
2840 virtual void PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2841 virtual void PostCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2842 virtual bool PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { return false; };
2843 virtual void PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2844 virtual void PostCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {};
2845 virtual bool PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { return false; };
2846 virtual void PreCallRecordCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {};
2847 virtual void PostCallRecordCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {};
2848 virtual bool PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { return false; };
2849 virtual void PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {};
2850 virtual void PostCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {};
2851 virtual bool PreCallValidateCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { return false; };
2852 virtual void PreCallRecordCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2853 virtual void PostCallRecordCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2854 virtual bool PreCallValidateCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { return false; };
2855 virtual void PreCallRecordCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2856 virtual void PostCallRecordCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {};
2857 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; };
2858 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) {};
2859 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) {};
2860 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; };
2861 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) {};
2862 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) {};
2863 virtual bool PreCallValidateCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { return false; };
2864 virtual void PreCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {};
2865 virtual void PostCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {};
2866 virtual bool PreCallValidateCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { return false; };
2867 virtual void PreCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {};
2868 virtual void PostCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {};
2869 virtual bool PreCallValidateCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { return false; };
2870 virtual void PreCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
2871 virtual void PostCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
2872 virtual bool PreCallValidateCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { return false; };
2873 virtual void PreCallRecordCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {};
2874 virtual void PostCallRecordCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {};
2875 virtual bool PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { return false; };
2876 virtual void PreCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {};
2877 virtual void PostCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {};
2878 virtual bool PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { return false; };
2879 virtual void PreCallRecordCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {};
2880 virtual void PostCallRecordCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {};
2881 virtual bool PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { return false; };
2882 virtual void PreCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {};
2883 virtual void PostCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {};
2884 virtual bool PreCallValidateCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { return false; };
2885 virtual void PreCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {};
2886 virtual void PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {};
2887 virtual bool PreCallValidateCmdEndRenderPass(VkCommandBuffer commandBuffer) { return false; };
2888 virtual void PreCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) {};
2889 virtual void PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) {};
2890 virtual bool PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { return false; };
2891 virtual void PreCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2892 virtual void PostCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {};
2893 virtual bool PreCallValidateBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { return false; };
2894 virtual void PreCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {};
2895 virtual void PostCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult result) {};
2896 virtual bool PreCallValidateBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { return false; };
2897 virtual void PreCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {};
2898 virtual void PostCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult result) {};
2899 virtual bool PreCallValidateGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { return false; };
2900 virtual void PreCallRecordGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
2901 virtual void PostCallRecordGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
2902 virtual bool PreCallValidateCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { return false; };
2903 virtual void PreCallRecordCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
2904 virtual void PostCallRecordCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
2905 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; };
2906 virtual void PreCallRecordCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2907 virtual void PostCallRecordCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
2908 virtual bool PreCallValidateEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { return false; };
2909 virtual void PreCallRecordEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {};
2910 virtual void PostCallRecordEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult result) {};
2911 virtual bool PreCallValidateGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
2912 virtual void PreCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2913 virtual void PostCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2914 virtual bool PreCallValidateGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
2915 virtual void PreCallRecordGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2916 virtual void PostCallRecordGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
2917 virtual bool PreCallValidateGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { return false; };
2918 virtual void PreCallRecordGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
2919 virtual void PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
2920 virtual bool PreCallValidateGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { return false; };
2921 virtual void PreCallRecordGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
2922 virtual void PostCallRecordGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
2923 virtual bool PreCallValidateGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { return false; };
2924 virtual void PreCallRecordGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
2925 virtual void PostCallRecordGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
2926 virtual bool PreCallValidateGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { return false; };
2927 virtual void PreCallRecordGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
2928 virtual void PostCallRecordGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
2929 virtual bool PreCallValidateGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { return false; };
2930 virtual void PreCallRecordGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {};
2931 virtual void PostCallRecordGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult result) {};
2932 virtual bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { return false; };
2933 virtual void PreCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
2934 virtual void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
2935 virtual bool PreCallValidateGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { return false; };
2936 virtual void PreCallRecordGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
2937 virtual void PostCallRecordGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
2938 virtual bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { return false; };
2939 virtual void PreCallRecordGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
2940 virtual void PostCallRecordGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
2941 virtual bool PreCallValidateTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { return false; };
2942 virtual void PreCallRecordTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
2943 virtual void PostCallRecordTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
2944 virtual bool PreCallValidateGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { return false; };
2945 virtual void PreCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {};
2946 virtual void PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {};
2947 virtual bool PreCallValidateCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return false; };
2948 virtual void PreCallRecordCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {};
2949 virtual void PostCallRecordCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result) {};
2950 virtual bool PreCallValidateDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { return false; };
2951 virtual void PreCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
2952 virtual void PostCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
2953 virtual bool PreCallValidateCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { return false; };
2954 virtual void PreCallRecordCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {};
2955 virtual void PostCallRecordCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult result) {};
2956 virtual bool PreCallValidateDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { return false; };
2957 virtual void PreCallRecordDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
2958 virtual void PostCallRecordDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
2959 virtual bool PreCallValidateUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { return false; };
2960 virtual void PreCallRecordUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
2961 virtual void PostCallRecordUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
2962 virtual bool PreCallValidateGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { return false; };
2963 virtual void PreCallRecordGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
2964 virtual void PostCallRecordGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
2965 virtual bool PreCallValidateGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { return false; };
2966 virtual void PreCallRecordGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
2967 virtual void PostCallRecordGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
2968 virtual bool PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { return false; };
2969 virtual void PreCallRecordGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
2970 virtual void PostCallRecordGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
2971 virtual bool PreCallValidateGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { return false; };
2972 virtual void PreCallRecordGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
2973 virtual void PostCallRecordGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
2974 virtual bool PreCallValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { return false; };
2975 virtual void PreCallRecordDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {};
2976 virtual void PostCallRecordDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {};
2977 virtual bool PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { return false; };
2978 virtual void PreCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {};
2979 virtual void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported, VkResult result) {};
2980 virtual bool PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { return false; };
2981 virtual void PreCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {};
2982 virtual void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, VkResult result) {};
2983 virtual bool PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { return false; };
2984 virtual void PreCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {};
2985 virtual void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats, VkResult result) {};
2986 virtual bool PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { return false; };
2987 virtual void PreCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {};
2988 virtual void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, VkResult result) {};
2989 virtual bool PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { return false; };
2990 virtual void PreCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {};
2991 virtual void PostCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain, VkResult result) {};
2992 virtual bool PreCallValidateDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { return false; };
2993 virtual void PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {};
2994 virtual void PostCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {};
2995 virtual bool PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { return false; };
2996 virtual void PreCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {};
2997 virtual void PostCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages, VkResult result) {};
2998 virtual bool PreCallValidateAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { return false; };
2999 virtual void PreCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {};
3000 virtual void PostCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex, VkResult result) {};
3001 virtual bool PreCallValidateQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { return false; };
3002 virtual void PreCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {};
3003 virtual void PostCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo, VkResult result) {};
3004 virtual bool PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { return false; };
3005 virtual void PreCallRecordGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {};
3006 virtual void PostCallRecordGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, VkResult result) {};
3007 virtual bool PreCallValidateGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { return false; };
3008 virtual void PreCallRecordGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {};
3009 virtual void PostCallRecordGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes, VkResult result) {};
3010 virtual bool PreCallValidateGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { return false; };
3011 virtual void PreCallRecordGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) {};
3012 virtual void PostCallRecordGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects, VkResult result) {};
3013 virtual bool PreCallValidateAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { return false; };
3014 virtual void PreCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) {};
3015 virtual void PostCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, VkResult result) {};
3016 virtual bool PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) { return false; };
3017 virtual void PreCallRecordGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) {};
3018 virtual void PostCallRecordGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties, VkResult result) {};
3019 virtual bool PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) { return false; };
3020 virtual void PreCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) {};
3021 virtual void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties, VkResult result) {};
3022 virtual bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { return false; };
3023 virtual void PreCallRecordGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) {};
3024 virtual void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays, VkResult result) {};
3025 virtual bool PreCallValidateGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) { return false; };
3026 virtual void PreCallRecordGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) {};
3027 virtual void PostCallRecordGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties, VkResult result) {};
3028 virtual bool PreCallValidateCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { return false; };
3029 virtual void PreCallRecordCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {};
3030 virtual void PostCallRecordCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode, VkResult result) {};
3031 virtual bool PreCallValidateGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) { return false; };
3032 virtual void PreCallRecordGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) {};
3033 virtual void PostCallRecordGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities, VkResult result) {};
3034 virtual bool PreCallValidateCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3035 virtual void PreCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3036 virtual void PostCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3037 virtual bool PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { return false; };
3038 virtual void PreCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {};
3039 virtual void PostCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains, VkResult result) {};
3040#ifdef VK_USE_PLATFORM_XLIB_KHR
3041 virtual bool PreCallValidateCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3042 virtual void PreCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3043 virtual void PostCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3044#endif
3045#ifdef VK_USE_PLATFORM_XLIB_KHR
3046 virtual bool PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { return false; };
3047 virtual void PreCallRecordGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) {};
3048 virtual void PostCallRecordGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) {};
3049#endif
3050#ifdef VK_USE_PLATFORM_XCB_KHR
3051 virtual bool PreCallValidateCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3052 virtual void PreCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3053 virtual void PostCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3054#endif
3055#ifdef VK_USE_PLATFORM_XCB_KHR
3056 virtual bool PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { return false; };
3057 virtual void PreCallRecordGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) {};
3058 virtual void PostCallRecordGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) {};
3059#endif
3060#ifdef VK_USE_PLATFORM_WAYLAND_KHR
3061 virtual bool PreCallValidateCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3062 virtual void PreCallRecordCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3063 virtual void PostCallRecordCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3064#endif
3065#ifdef VK_USE_PLATFORM_WAYLAND_KHR
3066 virtual bool PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { return false; };
3067 virtual void PreCallRecordGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) {};
3068 virtual void PostCallRecordGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) {};
3069#endif
3070#ifdef VK_USE_PLATFORM_ANDROID_KHR
3071 virtual bool PreCallValidateCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3072 virtual void PreCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3073 virtual void PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3074#endif
3075#ifdef VK_USE_PLATFORM_WIN32_KHR
3076 virtual bool PreCallValidateCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3077 virtual void PreCallRecordCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3078 virtual void PostCallRecordCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3079#endif
3080#ifdef VK_USE_PLATFORM_WIN32_KHR
3081 virtual bool PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { return false; };
3082 virtual void PreCallRecordGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {};
3083 virtual void PostCallRecordGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {};
3084#endif
3085 virtual bool PreCallValidateGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { return false; };
3086 virtual void PreCallRecordGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
3087 virtual void PostCallRecordGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {};
3088 virtual bool PreCallValidateGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { return false; };
3089 virtual void PreCallRecordGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
3090 virtual void PostCallRecordGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {};
3091 virtual bool PreCallValidateGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { return false; };
3092 virtual void PreCallRecordGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
3093 virtual void PostCallRecordGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {};
3094 virtual bool PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { return false; };
3095 virtual void PreCallRecordGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {};
3096 virtual void PostCallRecordGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult result) {};
3097 virtual bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { return false; };
3098 virtual void PreCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
3099 virtual void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {};
3100 virtual bool PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { return false; };
3101 virtual void PreCallRecordGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
3102 virtual void PostCallRecordGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {};
3103 virtual bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { return false; };
3104 virtual void PreCallRecordGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
3105 virtual void PostCallRecordGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {};
3106 virtual bool PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { return false; };
3107 virtual void PreCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
3108 virtual void PostCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {};
3109 virtual bool PreCallValidateCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) { return false; };
3110 virtual void PreCallRecordCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
3111 virtual void PostCallRecordCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) {};
3112 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; };
3113 virtual void PreCallRecordCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
3114 virtual void PostCallRecordCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {};
3115 virtual bool PreCallValidateTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { return false; };
3116 virtual void PreCallRecordTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
3117 virtual void PostCallRecordTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {};
3118 virtual bool PreCallValidateEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { return false; };
3119 virtual void PreCallRecordEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {};
3120 virtual void PostCallRecordEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult result) {};
3121 virtual bool PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { return false; };
3122 virtual void PreCallRecordGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
3123 virtual void PostCallRecordGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {};
3124#ifdef VK_USE_PLATFORM_WIN32_KHR
3125 virtual bool PreCallValidateGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { return false; };
3126 virtual void PreCallRecordGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {};
3127 virtual void PostCallRecordGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, VkResult result) {};
3128#endif
3129#ifdef VK_USE_PLATFORM_WIN32_KHR
3130 virtual bool PreCallValidateGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { return false; };
3131 virtual void PreCallRecordGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {};
3132 virtual void PostCallRecordGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, VkResult result) {};
3133#endif
3134 virtual bool PreCallValidateGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { return false; };
3135 virtual void PreCallRecordGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {};
3136 virtual void PostCallRecordGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result) {};
3137 virtual bool PreCallValidateGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { return false; };
3138 virtual void PreCallRecordGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) {};
3139 virtual void PostCallRecordGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties, VkResult result) {};
3140 virtual bool PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { return false; };
3141 virtual void PreCallRecordGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
3142 virtual void PostCallRecordGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {};
3143#ifdef VK_USE_PLATFORM_WIN32_KHR
3144 virtual bool PreCallValidateImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { return false; };
3145 virtual void PreCallRecordImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {};
3146 virtual void PostCallRecordImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, VkResult result) {};
3147#endif
3148#ifdef VK_USE_PLATFORM_WIN32_KHR
3149 virtual bool PreCallValidateGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { return false; };
3150 virtual void PreCallRecordGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {};
3151 virtual void PostCallRecordGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, VkResult result) {};
3152#endif
3153 virtual bool PreCallValidateImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { return false; };
3154 virtual void PreCallRecordImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {};
3155 virtual void PostCallRecordImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, VkResult result) {};
3156 virtual bool PreCallValidateGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { return false; };
3157 virtual void PreCallRecordGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {};
3158 virtual void PostCallRecordGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result) {};
3159 virtual bool PreCallValidateCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { return false; };
3160 virtual void PreCallRecordCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {};
3161 virtual void PostCallRecordCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {};
3162 virtual bool PreCallValidateCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { return false; };
3163 virtual void PreCallRecordCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {};
3164 virtual void PostCallRecordCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {};
3165 virtual bool PreCallValidateCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { return false; };
3166 virtual void PreCallRecordCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {};
3167 virtual void PostCallRecordCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult result) {};
3168 virtual bool PreCallValidateDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { return false; };
3169 virtual void PreCallRecordDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
3170 virtual void PostCallRecordDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {};
3171 virtual bool PreCallValidateUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { return false; };
3172 virtual void PreCallRecordUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
3173 virtual void PostCallRecordUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {};
3174 virtual bool PreCallValidateCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { return false; };
3175 virtual void PreCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {};
3176 virtual void PostCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result) {};
3177 virtual bool PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) { return false; };
3178 virtual void PreCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {};
3179 virtual void PostCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {};
3180 virtual bool PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) { return false; };
3181 virtual void PreCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3182 virtual void PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3183 virtual bool PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) { return false; };
3184 virtual void PreCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3185 virtual void PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) {};
3186 virtual bool PreCallValidateGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { return false; };
3187 virtual void PreCallRecordGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {};
3188 virtual void PostCallRecordGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain, VkResult result) {};
3189 virtual bool PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { return false; };
3190 virtual void PreCallRecordGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
3191 virtual void PostCallRecordGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {};
3192#ifdef VK_USE_PLATFORM_WIN32_KHR
3193 virtual bool PreCallValidateImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { return false; };
3194 virtual void PreCallRecordImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {};
3195 virtual void PostCallRecordImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, VkResult result) {};
3196#endif
3197#ifdef VK_USE_PLATFORM_WIN32_KHR
3198 virtual bool PreCallValidateGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { return false; };
3199 virtual void PreCallRecordGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {};
3200 virtual void PostCallRecordGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, VkResult result) {};
3201#endif
3202 virtual bool PreCallValidateImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { return false; };
3203 virtual void PreCallRecordImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {};
3204 virtual void PostCallRecordImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo, VkResult result) {};
3205 virtual bool PreCallValidateGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { return false; };
3206 virtual void PreCallRecordGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {};
3207 virtual void PostCallRecordGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result) {};
3208 virtual bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { return false; };
3209 virtual void PreCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {};
3210 virtual void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities, VkResult result) {};
3211 virtual bool PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { return false; };
3212 virtual void PreCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) {};
3213 virtual void PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats, VkResult result) {};
3214 virtual bool PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) { return false; };
3215 virtual void PreCallRecordGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) {};
3216 virtual void PostCallRecordGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties, VkResult result) {};
3217 virtual bool PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) { return false; };
3218 virtual void PreCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) {};
3219 virtual void PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties, VkResult result) {};
3220 virtual bool PreCallValidateGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) { return false; };
3221 virtual void PreCallRecordGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) {};
3222 virtual void PostCallRecordGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties, VkResult result) {};
3223 virtual bool PreCallValidateGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) { return false; };
3224 virtual void PreCallRecordGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) {};
3225 virtual void PostCallRecordGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities, VkResult result) {};
3226 virtual bool PreCallValidateGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
3227 virtual void PreCallRecordGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3228 virtual void PostCallRecordGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3229 virtual bool PreCallValidateGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { return false; };
3230 virtual void PreCallRecordGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3231 virtual void PostCallRecordGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {};
3232 virtual bool PreCallValidateGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { return false; };
3233 virtual void PreCallRecordGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
3234 virtual void PostCallRecordGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {};
3235 virtual bool PreCallValidateCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return false; };
3236 virtual void PreCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {};
3237 virtual void PostCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result) {};
3238 virtual bool PreCallValidateDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { return false; };
3239 virtual void PreCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
3240 virtual void PostCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {};
3241 virtual bool PreCallValidateBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { return false; };
3242 virtual void PreCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {};
3243 virtual void PostCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult result) {};
3244 virtual bool PreCallValidateBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { return false; };
3245 virtual void PreCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {};
3246 virtual void PostCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult result) {};
3247 virtual bool PreCallValidateGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { return false; };
3248 virtual void PreCallRecordGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
3249 virtual void PostCallRecordGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {};
3250 virtual bool PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3251 virtual void PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3252 virtual void PostCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3253 virtual bool PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3254 virtual void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3255 virtual void PostCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3256 virtual bool PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { return false; };
3257 virtual void PreCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {};
3258 virtual void PostCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, VkResult result) {};
3259 virtual bool PreCallValidateDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { return false; };
3260 virtual void PreCallRecordDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {};
3261 virtual void PostCallRecordDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {};
3262 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; };
3263 virtual void PreCallRecordDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {};
3264 virtual void PostCallRecordDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {};
3265 virtual bool PreCallValidateDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { return false; };
3266 virtual void PreCallRecordDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {};
3267 virtual void PostCallRecordDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo, VkResult result) {};
3268 virtual bool PreCallValidateDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { return false; };
3269 virtual void PreCallRecordDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {};
3270 virtual void PostCallRecordDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo, VkResult result) {};
3271 virtual bool PreCallValidateCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { return false; };
3272 virtual void PreCallRecordCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3273 virtual void PostCallRecordCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3274 virtual bool PreCallValidateCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { return false; };
3275 virtual void PreCallRecordCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {};
3276 virtual void PostCallRecordCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {};
3277 virtual bool PreCallValidateCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { return false; };
3278 virtual void PreCallRecordCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3279 virtual void PostCallRecordCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {};
3280 virtual bool PreCallValidateCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { return false; };
3281 virtual void PreCallRecordCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {};
3282 virtual void PostCallRecordCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {};
3283 virtual bool PreCallValidateCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { return false; };
3284 virtual void PreCallRecordCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3285 virtual void PostCallRecordCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3286 virtual bool PreCallValidateCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { return false; };
3287 virtual void PreCallRecordCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3288 virtual void PostCallRecordCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {};
3289 virtual bool PreCallValidateCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { return false; };
3290 virtual void PreCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {};
3291 virtual void PostCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {};
3292 virtual bool PreCallValidateCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { return false; };
3293 virtual void PreCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {};
3294 virtual void PostCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {};
3295 virtual bool PreCallValidateCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { return false; };
3296 virtual void PreCallRecordCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {};
3297 virtual void PostCallRecordCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {};
3298 virtual bool PreCallValidateGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { return false; };
3299 virtual void PreCallRecordGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {};
3300 virtual void PostCallRecordGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {};
3301 virtual bool PreCallValidateCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3302 virtual void PreCallRecordCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3303 virtual void PostCallRecordCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3304 virtual bool PreCallValidateCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3305 virtual void PreCallRecordCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3306 virtual void PostCallRecordCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3307 virtual bool PreCallValidateGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { return false; };
3308 virtual void PreCallRecordGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {};
3309 virtual void PostCallRecordGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, VkResult result) {};
3310#ifdef VK_USE_PLATFORM_GGP
3311 virtual bool PreCallValidateCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3312 virtual void PreCallRecordCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3313 virtual void PostCallRecordCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3314#endif
3315 virtual bool PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { return false; };
3316 virtual void PreCallRecordGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {};
3317 virtual void PostCallRecordGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, VkResult result) {};
3318#ifdef VK_USE_PLATFORM_WIN32_KHR
3319 virtual bool PreCallValidateGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { return false; };
3320 virtual void PreCallRecordGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) {};
3321 virtual void PostCallRecordGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, VkResult result) {};
3322#endif
3323#ifdef VK_USE_PLATFORM_VI_NN
3324 virtual bool PreCallValidateCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3325 virtual void PreCallRecordCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3326 virtual void PostCallRecordCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3327#endif
3328 virtual bool PreCallValidateCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { return false; };
3329 virtual void PreCallRecordCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {};
3330 virtual void PostCallRecordCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {};
3331 virtual bool PreCallValidateCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) { return false; };
3332 virtual void PreCallRecordCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {};
3333 virtual void PostCallRecordCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {};
3334 virtual bool PreCallValidateCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) { return false; };
3335 virtual void PreCallRecordCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {};
3336 virtual void PostCallRecordCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {};
3337 virtual bool PreCallValidateCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) { return false; };
3338 virtual void PreCallRecordCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {};
3339 virtual void PostCallRecordCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {};
3340 virtual bool PreCallValidateCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) { return false; };
3341 virtual void PreCallRecordCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) {};
3342 virtual void PostCallRecordCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout, VkResult result) {};
3343 virtual bool PreCallValidateDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { return false; };
3344 virtual void PreCallRecordDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {};
3345 virtual void PostCallRecordDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {};
3346 virtual bool PreCallValidateCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) { return false; };
3347 virtual void PreCallRecordCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) {};
3348 virtual void PostCallRecordCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable, VkResult result) {};
3349 virtual bool PreCallValidateDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) { return false; };
3350 virtual void PreCallRecordDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) {};
3351 virtual void PostCallRecordDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) {};
3352 virtual bool PreCallValidateRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices) { return false; };
3353 virtual void PreCallRecordRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices) {};
3354 virtual void PostCallRecordRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, VkResult result) {};
3355 virtual bool PreCallValidateUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices) { return false; };
3356 virtual void PreCallRecordUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices) {};
3357 virtual void PostCallRecordUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, VkResult result) {};
3358 virtual bool PreCallValidateGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) { return false; };
3359 virtual void PreCallRecordGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) {};
3360 virtual void PostCallRecordGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) {};
3361 virtual bool PreCallValidateCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { return false; };
3362 virtual void PreCallRecordCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {};
3363 virtual void PostCallRecordCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {};
3364 virtual bool PreCallValidateReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { return false; };
3365 virtual void PreCallRecordReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {};
3366 virtual void PostCallRecordReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkResult result) {};
3367#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3368 virtual bool PreCallValidateAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { return false; };
3369 virtual void PreCallRecordAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) {};
3370 virtual void PostCallRecordAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display, VkResult result) {};
3371#endif
3372#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3373 virtual bool PreCallValidateGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) { return false; };
3374 virtual void PreCallRecordGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) {};
3375 virtual void PostCallRecordGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay, VkResult result) {};
3376#endif
3377 virtual bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { return false; };
3378 virtual void PreCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {};
3379 virtual void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities, VkResult result) {};
3380 virtual bool PreCallValidateDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { return false; };
3381 virtual void PreCallRecordDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {};
3382 virtual void PostCallRecordDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo, VkResult result) {};
3383 virtual bool PreCallValidateRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { return false; };
3384 virtual void PreCallRecordRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {};
3385 virtual void PostCallRecordRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult result) {};
3386 virtual bool PreCallValidateRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { return false; };
3387 virtual void PreCallRecordRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {};
3388 virtual void PostCallRecordRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult result) {};
3389 virtual bool PreCallValidateGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { return false; };
3390 virtual void PreCallRecordGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) {};
3391 virtual void PostCallRecordGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, VkResult result) {};
3392 virtual bool PreCallValidateGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { return false; };
3393 virtual void PreCallRecordGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {};
3394 virtual void PostCallRecordGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, VkResult result) {};
3395 virtual bool PreCallValidateGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { return false; };
3396 virtual void PreCallRecordGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {};
3397 virtual void PostCallRecordGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings, VkResult result) {};
3398 virtual bool PreCallValidateCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { return false; };
3399 virtual void PreCallRecordCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {};
3400 virtual void PostCallRecordCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {};
3401 virtual bool PreCallValidateSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { return false; };
3402 virtual void PreCallRecordSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {};
3403 virtual void PostCallRecordSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {};
3404#ifdef VK_USE_PLATFORM_IOS_MVK
3405 virtual bool PreCallValidateCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3406 virtual void PreCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3407 virtual void PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3408#endif
3409#ifdef VK_USE_PLATFORM_MACOS_MVK
3410 virtual bool PreCallValidateCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3411 virtual void PreCallRecordCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3412 virtual void PostCallRecordCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3413#endif
3414 virtual bool PreCallValidateSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { return false; };
3415 virtual void PreCallRecordSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {};
3416 virtual void PostCallRecordSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo, VkResult result) {};
3417 virtual bool PreCallValidateSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { return false; };
3418 virtual void PreCallRecordSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {};
3419 virtual void PostCallRecordSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo, VkResult result) {};
3420 virtual bool PreCallValidateQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3421 virtual void PreCallRecordQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3422 virtual void PostCallRecordQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3423 virtual bool PreCallValidateQueueEndDebugUtilsLabelEXT(VkQueue queue) { return false; };
3424 virtual void PreCallRecordQueueEndDebugUtilsLabelEXT(VkQueue queue) {};
3425 virtual void PostCallRecordQueueEndDebugUtilsLabelEXT(VkQueue queue) {};
3426 virtual bool PreCallValidateQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3427 virtual void PreCallRecordQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3428 virtual void PostCallRecordQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3429 virtual bool PreCallValidateCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3430 virtual void PreCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3431 virtual void PostCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3432 virtual bool PreCallValidateCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { return false; };
3433 virtual void PreCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {};
3434 virtual void PostCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {};
3435 virtual bool PreCallValidateCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { return false; };
3436 virtual void PreCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3437 virtual void PostCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {};
3438 virtual bool PreCallValidateCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { return false; };
3439 virtual void PreCallRecordCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) {};
3440 virtual void PostCallRecordCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger, VkResult result) {};
3441 virtual bool PreCallValidateDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { return false; };
3442 virtual void PreCallRecordDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {};
3443 virtual void PostCallRecordDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {};
3444 virtual bool PreCallValidateSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { return false; };
3445 virtual void PreCallRecordSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {};
3446 virtual void PostCallRecordSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {};
3447#ifdef VK_USE_PLATFORM_ANDROID_KHR
3448 virtual bool PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { return false; };
3449 virtual void PreCallRecordGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) {};
3450 virtual void PostCallRecordGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties, VkResult result) {};
3451#endif
3452#ifdef VK_USE_PLATFORM_ANDROID_KHR
3453 virtual bool PreCallValidateGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { return false; };
3454 virtual void PreCallRecordGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) {};
3455 virtual void PostCallRecordGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, VkResult result) {};
3456#endif
3457 virtual bool PreCallValidateCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { return false; };
3458 virtual void PreCallRecordCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {};
3459 virtual void PostCallRecordCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {};
3460 virtual bool PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) { return false; };
3461 virtual void PreCallRecordGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {};
3462 virtual void PostCallRecordGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {};
3463 virtual bool PreCallValidateGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { return false; };
3464 virtual void PreCallRecordGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {};
3465 virtual void PostCallRecordGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, VkResult result) {};
3466 virtual bool PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { return false; };
3467 virtual void PreCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {};
3468 virtual void PostCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {};
3469 virtual bool PreCallValidateCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { return false; };
3470 virtual void PreCallRecordCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {};
3471 virtual void PostCallRecordCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {};
3472 virtual bool PreCallValidateCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { return false; };
3473 virtual void PreCallRecordCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {};
3474 virtual void PostCallRecordCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {};
3475 virtual bool PreCallValidateCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { return false; };
3476 virtual void PreCallRecordCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) {};
3477 virtual void PostCallRecordCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure, VkResult result) {};
3478 virtual bool PreCallValidateDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { return false; };
3479 virtual void PreCallRecordDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) {};
3480 virtual void PostCallRecordDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) {};
3481 virtual bool PreCallValidateGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { return false; };
3482 virtual void PreCallRecordGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) {};
3483 virtual void PostCallRecordGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) {};
3484 virtual bool PreCallValidateBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { return false; };
3485 virtual void PreCallRecordBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {};
3486 virtual void PostCallRecordBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, VkResult result) {};
3487 virtual bool PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { return false; };
3488 virtual void PreCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {};
3489 virtual void PostCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {};
3490 virtual bool PreCallValidateCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) { return false; };
3491 virtual void PreCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) {};
3492 virtual void PostCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) {};
3493 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; };
3494 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) {};
3495 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) {};
3496 virtual bool PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; };
3497 virtual void PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {};
3498 virtual void PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {};
3499 virtual bool PreCallValidateGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { return false; };
3500 virtual void PreCallRecordGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {};
3501 virtual void PostCallRecordGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult result) {};
3502 virtual bool PreCallValidateGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { return false; };
3503 virtual void PreCallRecordGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) {};
3504 virtual void PostCallRecordGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, VkResult result) {};
3505 virtual bool PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { return false; };
3506 virtual void PreCallRecordCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {};
3507 virtual void PostCallRecordCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {};
3508 virtual bool PreCallValidateCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) { return false; };
3509 virtual void PreCallRecordCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) {};
3510 virtual void PostCallRecordCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader, VkResult result) {};
3511 virtual bool PreCallValidateGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { return false; };
3512 virtual void PreCallRecordGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {};
3513 virtual void PostCallRecordGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, VkResult result) {};
3514 virtual bool PreCallValidateCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { return false; };
3515 virtual void PreCallRecordCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {};
3516 virtual void PostCallRecordCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {};
3517 virtual bool PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) { return false; };
3518 virtual void PreCallRecordGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) {};
3519 virtual void PostCallRecordGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains, VkResult result) {};
3520 virtual bool PreCallValidateGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { return false; };
3521 virtual void PreCallRecordGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {};
3522 virtual void PostCallRecordGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, VkResult result) {};
3523 virtual bool PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { return false; };
3524 virtual void PreCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {};
3525 virtual void PostCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {};
3526 virtual bool PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { return false; };
3527 virtual void PreCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
3528 virtual void PostCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {};
3529 virtual bool PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { return false; };
3530 virtual void PreCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3531 virtual void PostCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
3532 virtual bool PreCallValidateCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { return false; };
3533 virtual void PreCallRecordCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {};
3534 virtual void PostCallRecordCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {};
3535 virtual bool PreCallValidateCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { return false; };
3536 virtual void PreCallRecordCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {};
3537 virtual void PostCallRecordCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {};
3538 virtual bool PreCallValidateGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { return false; };
3539 virtual void PreCallRecordGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {};
3540 virtual void PostCallRecordGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {};
3541 virtual bool PreCallValidateInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { return false; };
3542 virtual void PreCallRecordInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {};
3543 virtual void PostCallRecordInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, VkResult result) {};
3544 virtual bool PreCallValidateUninitializePerformanceApiINTEL(VkDevice device) { return false; };
3545 virtual void PreCallRecordUninitializePerformanceApiINTEL(VkDevice device) {};
3546 virtual void PostCallRecordUninitializePerformanceApiINTEL(VkDevice device) {};
3547 virtual bool PreCallValidateCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { return false; };
3548 virtual void PreCallRecordCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {};
3549 virtual void PostCallRecordCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo, VkResult result) {};
3550 virtual bool PreCallValidateCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { return false; };
3551 virtual void PreCallRecordCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {};
3552 virtual void PostCallRecordCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo, VkResult result) {};
3553 virtual bool PreCallValidateCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { return false; };
3554 virtual void PreCallRecordCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {};
3555 virtual void PostCallRecordCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo, VkResult result) {};
3556 virtual bool PreCallValidateAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { return false; };
3557 virtual void PreCallRecordAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) {};
3558 virtual void PostCallRecordAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration, VkResult result) {};
3559 virtual bool PreCallValidateReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) { return false; };
3560 virtual void PreCallRecordReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) {};
3561 virtual void PostCallRecordReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration, VkResult result) {};
3562 virtual bool PreCallValidateQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) { return false; };
3563 virtual void PreCallRecordQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) {};
3564 virtual void PostCallRecordQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration, VkResult result) {};
3565 virtual bool PreCallValidateGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { return false; };
3566 virtual void PreCallRecordGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) {};
3567 virtual void PostCallRecordGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue, VkResult result) {};
3568 virtual bool PreCallValidateSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { return false; };
3569 virtual void PreCallRecordSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {};
3570 virtual void PostCallRecordSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {};
3571#ifdef VK_USE_PLATFORM_FUCHSIA
3572 virtual bool PreCallValidateCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3573 virtual void PreCallRecordCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3574 virtual void PostCallRecordCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3575#endif
3576#ifdef VK_USE_PLATFORM_METAL_EXT
3577 virtual bool PreCallValidateCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3578 virtual void PreCallRecordCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3579 virtual void PostCallRecordCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3580#endif
3581 virtual bool PreCallValidateGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) { return false; };
3582 virtual void PreCallRecordGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) {};
3583 virtual void PostCallRecordGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) {};
3584 virtual bool PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) { return false; };
3585 virtual void PreCallRecordGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) {};
3586 virtual void PostCallRecordGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties, VkResult result) {};
3587 virtual bool PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { return false; };
3588 virtual void PreCallRecordGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) {};
3589 virtual void PostCallRecordGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations, VkResult result) {};
3590#ifdef VK_USE_PLATFORM_WIN32_KHR
3591 virtual bool PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { return false; };
3592 virtual void PreCallRecordGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {};
3593 virtual void PostCallRecordGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, VkResult result) {};
3594#endif
3595#ifdef VK_USE_PLATFORM_WIN32_KHR
3596 virtual bool PreCallValidateAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { return false; };
3597 virtual void PreCallRecordAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {};
3598 virtual void PostCallRecordAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain, VkResult result) {};
3599#endif
3600#ifdef VK_USE_PLATFORM_WIN32_KHR
3601 virtual bool PreCallValidateReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { return false; };
3602 virtual void PreCallRecordReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {};
3603 virtual void PostCallRecordReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain, VkResult result) {};
3604#endif
3605#ifdef VK_USE_PLATFORM_WIN32_KHR
3606 virtual bool PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { return false; };
3607 virtual void PreCallRecordGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) {};
3608 virtual void PostCallRecordGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes, VkResult result) {};
3609#endif
3610 virtual bool PreCallValidateCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return false; };
3611 virtual void PreCallRecordCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
3612 virtual void PostCallRecordCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
3613 virtual bool PreCallValidateResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { return false; };
3614 virtual void PreCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
3615 virtual void PostCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
3616
3617 virtual VkResult CoreLayerCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { return VK_SUCCESS; };
3618 virtual void CoreLayerDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) {};
3619 virtual VkResult CoreLayerMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { return VK_SUCCESS; };
3620 virtual VkResult CoreLayerGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { return VK_SUCCESS; };
3621
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame^]3622 // Allow additional state parameter for CreateGraphicsPipelines
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3623 virtual bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state) {
3624 return PreCallValidateCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3625 };
3626 virtual void PreCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state) {
3627 PreCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3628 };
3629 virtual void PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* cgpl_state) {
3630 PostCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
3631 };
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame^]3632
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3633 // Allow additional state parameter for CreateComputePipelines
3634 virtual bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state) {
3635 return PreCallValidateCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3636 };
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame^]3637 virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
3638 PreCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3639 };
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3640 virtual void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
3641 PostCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
3642 };
3643
3644 // Allow additional state parameter for CreateRayTracingPipelinesNV
3645 virtual bool PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state) {
3646 return PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3647 };
Jason Macnak67407e72019-07-11 11:05:09 -0700[diff] [blame^]3648 virtual void PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
3649 PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3650 };
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]3651 virtual void PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
3652 PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
3653 };
3654
3655 // Allow modification of a down-chain parameter for CreatePipelineLayout
3656 virtual void PreCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, void *cpl_state) {
3657 PreCallRecordCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
3658 };
3659
3660 // Enable the CreateShaderModule API to take an extra argument for state preservation and paramter modification
3661 virtual bool PreCallValidateCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, void* csm_state) {
3662 return PreCallValidateCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
3663 };
3664 virtual void PreCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, void* csm_state) {
3665 PreCallRecordCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
3666 };
3667 virtual void PostCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult result, void* csm_state) {
3668 PostCallRecordCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule, result);
3669 };
3670
3671 // Allow AllocateDescriptorSets to use some local stack storage for performance purposes
3672 virtual bool PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, void* ads_state) {
3673 return PreCallValidateAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
3674 };
3675 virtual void PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, VkResult result, void* ads_state) {
3676 PostCallRecordAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets, result);
3677 };
3678
3679 // Modify a parameter to CreateDevice
3680 virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, std::unique_ptr<safe_VkDeviceCreateInfo> &modified_create_info) {
3681 PreCallRecordCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
3682 };
3683};
3684
3685extern std::unordered_map<void*, ValidationObject*> layer_data_map;