| // *** THIS FILE IS GENERATED - DO NOT EDIT *** | |
| // See object_tracker_generator.py for modifications | |
| /*************************************************************************** | |
| * | |
| * Copyright (c) 2015-2019 The Khronos Group Inc. | |
| * Copyright (c) 2015-2019 Valve Corporation | |
| * Copyright (c) 2015-2019 LunarG, Inc. | |
| * Copyright (c) 2015-2019 Google Inc. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| * Author: Mark Lobodzinski <mark@lunarg.com> | |
| * Author: Dave Houlton <daveh@lunarg.com> | |
| * | |
| ****************************************************************************/ | |
| void PostCallRecordCreateInstance( | |
| const VkInstanceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkInstance* pInstance, | |
| VkResult result); | |
| bool PreCallValidateDestroyInstance( | |
| VkInstance instance, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyInstance( | |
| VkInstance instance, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateEnumeratePhysicalDevices( | |
| VkInstance instance, | |
| uint32_t* pPhysicalDeviceCount, | |
| VkPhysicalDevice* pPhysicalDevices); | |
| void PostCallRecordEnumeratePhysicalDevices( | |
| VkInstance instance, | |
| uint32_t* pPhysicalDeviceCount, | |
| VkPhysicalDevice* pPhysicalDevices, | |
| VkResult result); | |
| bool PreCallValidateGetPhysicalDeviceFeatures( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceFeatures* pFeatures); | |
| bool PreCallValidateGetPhysicalDeviceFormatProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkFormatProperties* pFormatProperties); | |
| bool PreCallValidateGetPhysicalDeviceImageFormatProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkImageType type, | |
| VkImageTiling tiling, | |
| VkImageUsageFlags usage, | |
| VkImageCreateFlags flags, | |
| VkImageFormatProperties* pImageFormatProperties); | |
| bool PreCallValidateGetPhysicalDeviceProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceProperties* pProperties); | |
| bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pQueueFamilyPropertyCount, | |
| VkQueueFamilyProperties* pQueueFamilyProperties); | |
| bool PreCallValidateGetPhysicalDeviceMemoryProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties); | |
| bool PreCallValidateGetInstanceProcAddr( | |
| VkInstance instance, | |
| const char* pName); | |
| bool PreCallValidateGetDeviceProcAddr( | |
| VkDevice device, | |
| const char* pName); | |
| bool PreCallValidateCreateDevice( | |
| VkPhysicalDevice physicalDevice, | |
| const VkDeviceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDevice* pDevice); | |
| void PostCallRecordCreateDevice( | |
| VkPhysicalDevice physicalDevice, | |
| const VkDeviceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDevice* pDevice, | |
| VkResult result); | |
| bool PreCallValidateDestroyDevice( | |
| VkDevice device, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyDevice( | |
| VkDevice device, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateEnumerateDeviceExtensionProperties( | |
| VkPhysicalDevice physicalDevice, | |
| const char* pLayerName, | |
| uint32_t* pPropertyCount, | |
| VkExtensionProperties* pProperties); | |
| bool PreCallValidateEnumerateDeviceLayerProperties( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkLayerProperties* pProperties); | |
| bool PreCallValidateGetDeviceQueue( | |
| VkDevice device, | |
| uint32_t queueFamilyIndex, | |
| uint32_t queueIndex, | |
| VkQueue* pQueue); | |
| void PostCallRecordGetDeviceQueue( | |
| VkDevice device, | |
| uint32_t queueFamilyIndex, | |
| uint32_t queueIndex, | |
| VkQueue* pQueue); | |
| bool PreCallValidateQueueSubmit( | |
| VkQueue queue, | |
| uint32_t submitCount, | |
| const VkSubmitInfo* pSubmits, | |
| VkFence fence); | |
| bool PreCallValidateQueueWaitIdle( | |
| VkQueue queue); | |
| bool PreCallValidateDeviceWaitIdle( | |
| VkDevice device); | |
| bool PreCallValidateAllocateMemory( | |
| VkDevice device, | |
| const VkMemoryAllocateInfo* pAllocateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDeviceMemory* pMemory); | |
| void PostCallRecordAllocateMemory( | |
| VkDevice device, | |
| const VkMemoryAllocateInfo* pAllocateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDeviceMemory* pMemory, | |
| VkResult result); | |
| bool PreCallValidateFreeMemory( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordFreeMemory( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateMapMemory( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| VkDeviceSize offset, | |
| VkDeviceSize size, | |
| VkMemoryMapFlags flags, | |
| void** ppData); | |
| bool PreCallValidateUnmapMemory( | |
| VkDevice device, | |
| VkDeviceMemory memory); | |
| bool PreCallValidateFlushMappedMemoryRanges( | |
| VkDevice device, | |
| uint32_t memoryRangeCount, | |
| const VkMappedMemoryRange* pMemoryRanges); | |
| bool PreCallValidateInvalidateMappedMemoryRanges( | |
| VkDevice device, | |
| uint32_t memoryRangeCount, | |
| const VkMappedMemoryRange* pMemoryRanges); | |
| bool PreCallValidateGetDeviceMemoryCommitment( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| VkDeviceSize* pCommittedMemoryInBytes); | |
| bool PreCallValidateBindBufferMemory( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| VkDeviceMemory memory, | |
| VkDeviceSize memoryOffset); | |
| bool PreCallValidateBindImageMemory( | |
| VkDevice device, | |
| VkImage image, | |
| VkDeviceMemory memory, | |
| VkDeviceSize memoryOffset); | |
| bool PreCallValidateGetBufferMemoryRequirements( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| VkMemoryRequirements* pMemoryRequirements); | |
| bool PreCallValidateGetImageMemoryRequirements( | |
| VkDevice device, | |
| VkImage image, | |
| VkMemoryRequirements* pMemoryRequirements); | |
| bool PreCallValidateGetImageSparseMemoryRequirements( | |
| VkDevice device, | |
| VkImage image, | |
| uint32_t* pSparseMemoryRequirementCount, | |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements); | |
| bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkImageType type, | |
| VkSampleCountFlagBits samples, | |
| VkImageUsageFlags usage, | |
| VkImageTiling tiling, | |
| uint32_t* pPropertyCount, | |
| VkSparseImageFormatProperties* pProperties); | |
| bool PreCallValidateQueueBindSparse( | |
| VkQueue queue, | |
| uint32_t bindInfoCount, | |
| const VkBindSparseInfo* pBindInfo, | |
| VkFence fence); | |
| bool PreCallValidateCreateFence( | |
| VkDevice device, | |
| const VkFenceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence); | |
| void PostCallRecordCreateFence( | |
| VkDevice device, | |
| const VkFenceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence, | |
| VkResult result); | |
| bool PreCallValidateDestroyFence( | |
| VkDevice device, | |
| VkFence fence, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyFence( | |
| VkDevice device, | |
| VkFence fence, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateResetFences( | |
| VkDevice device, | |
| uint32_t fenceCount, | |
| const VkFence* pFences); | |
| bool PreCallValidateGetFenceStatus( | |
| VkDevice device, | |
| VkFence fence); | |
| bool PreCallValidateWaitForFences( | |
| VkDevice device, | |
| uint32_t fenceCount, | |
| const VkFence* pFences, | |
| VkBool32 waitAll, | |
| uint64_t timeout); | |
| bool PreCallValidateCreateSemaphore( | |
| VkDevice device, | |
| const VkSemaphoreCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSemaphore* pSemaphore); | |
| void PostCallRecordCreateSemaphore( | |
| VkDevice device, | |
| const VkSemaphoreCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSemaphore* pSemaphore, | |
| VkResult result); | |
| bool PreCallValidateDestroySemaphore( | |
| VkDevice device, | |
| VkSemaphore semaphore, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroySemaphore( | |
| VkDevice device, | |
| VkSemaphore semaphore, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateEvent( | |
| VkDevice device, | |
| const VkEventCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkEvent* pEvent); | |
| void PostCallRecordCreateEvent( | |
| VkDevice device, | |
| const VkEventCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkEvent* pEvent, | |
| VkResult result); | |
| bool PreCallValidateDestroyEvent( | |
| VkDevice device, | |
| VkEvent event, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyEvent( | |
| VkDevice device, | |
| VkEvent event, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetEventStatus( | |
| VkDevice device, | |
| VkEvent event); | |
| bool PreCallValidateSetEvent( | |
| VkDevice device, | |
| VkEvent event); | |
| bool PreCallValidateResetEvent( | |
| VkDevice device, | |
| VkEvent event); | |
| bool PreCallValidateCreateQueryPool( | |
| VkDevice device, | |
| const VkQueryPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkQueryPool* pQueryPool); | |
| void PostCallRecordCreateQueryPool( | |
| VkDevice device, | |
| const VkQueryPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkQueryPool* pQueryPool, | |
| VkResult result); | |
| bool PreCallValidateDestroyQueryPool( | |
| VkDevice device, | |
| VkQueryPool queryPool, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyQueryPool( | |
| VkDevice device, | |
| VkQueryPool queryPool, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetQueryPoolResults( | |
| VkDevice device, | |
| VkQueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| size_t dataSize, | |
| void* pData, | |
| VkDeviceSize stride, | |
| VkQueryResultFlags flags); | |
| bool PreCallValidateCreateBuffer( | |
| VkDevice device, | |
| const VkBufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBuffer* pBuffer); | |
| void PostCallRecordCreateBuffer( | |
| VkDevice device, | |
| const VkBufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBuffer* pBuffer, | |
| VkResult result); | |
| bool PreCallValidateDestroyBuffer( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyBuffer( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateBufferView( | |
| VkDevice device, | |
| const VkBufferViewCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBufferView* pView); | |
| void PostCallRecordCreateBufferView( | |
| VkDevice device, | |
| const VkBufferViewCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBufferView* pView, | |
| VkResult result); | |
| bool PreCallValidateDestroyBufferView( | |
| VkDevice device, | |
| VkBufferView bufferView, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyBufferView( | |
| VkDevice device, | |
| VkBufferView bufferView, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateImage( | |
| VkDevice device, | |
| const VkImageCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImage* pImage); | |
| void PostCallRecordCreateImage( | |
| VkDevice device, | |
| const VkImageCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImage* pImage, | |
| VkResult result); | |
| bool PreCallValidateDestroyImage( | |
| VkDevice device, | |
| VkImage image, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyImage( | |
| VkDevice device, | |
| VkImage image, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetImageSubresourceLayout( | |
| VkDevice device, | |
| VkImage image, | |
| const VkImageSubresource* pSubresource, | |
| VkSubresourceLayout* pLayout); | |
| bool PreCallValidateCreateImageView( | |
| VkDevice device, | |
| const VkImageViewCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImageView* pView); | |
| void PostCallRecordCreateImageView( | |
| VkDevice device, | |
| const VkImageViewCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImageView* pView, | |
| VkResult result); | |
| bool PreCallValidateDestroyImageView( | |
| VkDevice device, | |
| VkImageView imageView, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyImageView( | |
| VkDevice device, | |
| VkImageView imageView, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateShaderModule( | |
| VkDevice device, | |
| const VkShaderModuleCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkShaderModule* pShaderModule); | |
| void PostCallRecordCreateShaderModule( | |
| VkDevice device, | |
| const VkShaderModuleCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkShaderModule* pShaderModule, | |
| VkResult result); | |
| bool PreCallValidateDestroyShaderModule( | |
| VkDevice device, | |
| VkShaderModule shaderModule, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyShaderModule( | |
| VkDevice device, | |
| VkShaderModule shaderModule, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreatePipelineCache( | |
| VkDevice device, | |
| const VkPipelineCacheCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipelineCache* pPipelineCache); | |
| void PostCallRecordCreatePipelineCache( | |
| VkDevice device, | |
| const VkPipelineCacheCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipelineCache* pPipelineCache, | |
| VkResult result); | |
| bool PreCallValidateDestroyPipelineCache( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyPipelineCache( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetPipelineCacheData( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| size_t* pDataSize, | |
| void* pData); | |
| bool PreCallValidateMergePipelineCaches( | |
| VkDevice device, | |
| VkPipelineCache dstCache, | |
| uint32_t srcCacheCount, | |
| const VkPipelineCache* pSrcCaches); | |
| bool PreCallValidateCreateGraphicsPipelines( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines); | |
| void PostCallRecordCreateGraphicsPipelines( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines, | |
| VkResult result); | |
| bool PreCallValidateCreateComputePipelines( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkComputePipelineCreateInfo* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines); | |
| void PostCallRecordCreateComputePipelines( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkComputePipelineCreateInfo* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines, | |
| VkResult result); | |
| bool PreCallValidateDestroyPipeline( | |
| VkDevice device, | |
| VkPipeline pipeline, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyPipeline( | |
| VkDevice device, | |
| VkPipeline pipeline, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreatePipelineLayout( | |
| VkDevice device, | |
| const VkPipelineLayoutCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipelineLayout* pPipelineLayout); | |
| void PostCallRecordCreatePipelineLayout( | |
| VkDevice device, | |
| const VkPipelineLayoutCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipelineLayout* pPipelineLayout, | |
| VkResult result); | |
| bool PreCallValidateDestroyPipelineLayout( | |
| VkDevice device, | |
| VkPipelineLayout pipelineLayout, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyPipelineLayout( | |
| VkDevice device, | |
| VkPipelineLayout pipelineLayout, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateSampler( | |
| VkDevice device, | |
| const VkSamplerCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSampler* pSampler); | |
| void PostCallRecordCreateSampler( | |
| VkDevice device, | |
| const VkSamplerCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSampler* pSampler, | |
| VkResult result); | |
| bool PreCallValidateDestroySampler( | |
| VkDevice device, | |
| VkSampler sampler, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroySampler( | |
| VkDevice device, | |
| VkSampler sampler, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateDescriptorSetLayout( | |
| VkDevice device, | |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorSetLayout* pSetLayout); | |
| void PostCallRecordCreateDescriptorSetLayout( | |
| VkDevice device, | |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorSetLayout* pSetLayout, | |
| VkResult result); | |
| bool PreCallValidateDestroyDescriptorSetLayout( | |
| VkDevice device, | |
| VkDescriptorSetLayout descriptorSetLayout, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyDescriptorSetLayout( | |
| VkDevice device, | |
| VkDescriptorSetLayout descriptorSetLayout, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateDescriptorPool( | |
| VkDevice device, | |
| const VkDescriptorPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorPool* pDescriptorPool); | |
| void PostCallRecordCreateDescriptorPool( | |
| VkDevice device, | |
| const VkDescriptorPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorPool* pDescriptorPool, | |
| VkResult result); | |
| bool PreCallValidateDestroyDescriptorPool( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyDescriptorPool( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateResetDescriptorPool( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| VkDescriptorPoolResetFlags flags); | |
| bool PreCallValidateAllocateDescriptorSets( | |
| VkDevice device, | |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, | |
| VkDescriptorSet* pDescriptorSets); | |
| void PostCallRecordAllocateDescriptorSets( | |
| VkDevice device, | |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, | |
| VkDescriptorSet* pDescriptorSets, | |
| VkResult result); | |
| bool PreCallValidateFreeDescriptorSets( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| uint32_t descriptorSetCount, | |
| const VkDescriptorSet* pDescriptorSets); | |
| bool PreCallValidateUpdateDescriptorSets( | |
| VkDevice device, | |
| uint32_t descriptorWriteCount, | |
| const VkWriteDescriptorSet* pDescriptorWrites, | |
| uint32_t descriptorCopyCount, | |
| const VkCopyDescriptorSet* pDescriptorCopies); | |
| bool PreCallValidateCreateFramebuffer( | |
| VkDevice device, | |
| const VkFramebufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFramebuffer* pFramebuffer); | |
| void PostCallRecordCreateFramebuffer( | |
| VkDevice device, | |
| const VkFramebufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFramebuffer* pFramebuffer, | |
| VkResult result); | |
| bool PreCallValidateDestroyFramebuffer( | |
| VkDevice device, | |
| VkFramebuffer framebuffer, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyFramebuffer( | |
| VkDevice device, | |
| VkFramebuffer framebuffer, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateRenderPass( | |
| VkDevice device, | |
| const VkRenderPassCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkRenderPass* pRenderPass); | |
| void PostCallRecordCreateRenderPass( | |
| VkDevice device, | |
| const VkRenderPassCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkRenderPass* pRenderPass, | |
| VkResult result); | |
| bool PreCallValidateDestroyRenderPass( | |
| VkDevice device, | |
| VkRenderPass renderPass, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyRenderPass( | |
| VkDevice device, | |
| VkRenderPass renderPass, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetRenderAreaGranularity( | |
| VkDevice device, | |
| VkRenderPass renderPass, | |
| VkExtent2D* pGranularity); | |
| bool PreCallValidateCreateCommandPool( | |
| VkDevice device, | |
| const VkCommandPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkCommandPool* pCommandPool); | |
| void PostCallRecordCreateCommandPool( | |
| VkDevice device, | |
| const VkCommandPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkCommandPool* pCommandPool, | |
| VkResult result); | |
| bool PreCallValidateDestroyCommandPool( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyCommandPool( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateResetCommandPool( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| VkCommandPoolResetFlags flags); | |
| bool PreCallValidateAllocateCommandBuffers( | |
| VkDevice device, | |
| const VkCommandBufferAllocateInfo* pAllocateInfo, | |
| VkCommandBuffer* pCommandBuffers); | |
| void PostCallRecordAllocateCommandBuffers( | |
| VkDevice device, | |
| const VkCommandBufferAllocateInfo* pAllocateInfo, | |
| VkCommandBuffer* pCommandBuffers, | |
| VkResult result); | |
| bool PreCallValidateFreeCommandBuffers( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| uint32_t commandBufferCount, | |
| const VkCommandBuffer* pCommandBuffers); | |
| bool PreCallValidateBeginCommandBuffer( | |
| VkCommandBuffer commandBuffer, | |
| const VkCommandBufferBeginInfo* pBeginInfo); | |
| bool PreCallValidateEndCommandBuffer( | |
| VkCommandBuffer commandBuffer); | |
| bool PreCallValidateResetCommandBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkCommandBufferResetFlags flags); | |
| bool PreCallValidateCmdBindPipeline( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineBindPoint pipelineBindPoint, | |
| VkPipeline pipeline); | |
| bool PreCallValidateCmdSetViewport( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VkViewport* pViewports); | |
| bool PreCallValidateCmdSetScissor( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstScissor, | |
| uint32_t scissorCount, | |
| const VkRect2D* pScissors); | |
| bool PreCallValidateCmdSetLineWidth( | |
| VkCommandBuffer commandBuffer, | |
| float lineWidth); | |
| bool PreCallValidateCmdSetDepthBias( | |
| VkCommandBuffer commandBuffer, | |
| float depthBiasConstantFactor, | |
| float depthBiasClamp, | |
| float depthBiasSlopeFactor); | |
| bool PreCallValidateCmdSetBlendConstants( | |
| VkCommandBuffer commandBuffer, | |
| const float blendConstants[4]); | |
| bool PreCallValidateCmdSetDepthBounds( | |
| VkCommandBuffer commandBuffer, | |
| float minDepthBounds, | |
| float maxDepthBounds); | |
| bool PreCallValidateCmdSetStencilCompareMask( | |
| VkCommandBuffer commandBuffer, | |
| VkStencilFaceFlags faceMask, | |
| uint32_t compareMask); | |
| bool PreCallValidateCmdSetStencilWriteMask( | |
| VkCommandBuffer commandBuffer, | |
| VkStencilFaceFlags faceMask, | |
| uint32_t writeMask); | |
| bool PreCallValidateCmdSetStencilReference( | |
| VkCommandBuffer commandBuffer, | |
| VkStencilFaceFlags faceMask, | |
| uint32_t reference); | |
| bool PreCallValidateCmdBindDescriptorSets( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineBindPoint pipelineBindPoint, | |
| VkPipelineLayout layout, | |
| uint32_t firstSet, | |
| uint32_t descriptorSetCount, | |
| const VkDescriptorSet* pDescriptorSets, | |
| uint32_t dynamicOffsetCount, | |
| const uint32_t* pDynamicOffsets); | |
| bool PreCallValidateCmdBindIndexBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkIndexType indexType); | |
| bool PreCallValidateCmdBindVertexBuffers( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VkBuffer* pBuffers, | |
| const VkDeviceSize* pOffsets); | |
| bool PreCallValidateCmdDraw( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t vertexCount, | |
| uint32_t instanceCount, | |
| uint32_t firstVertex, | |
| uint32_t firstInstance); | |
| bool PreCallValidateCmdDrawIndexed( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t indexCount, | |
| uint32_t instanceCount, | |
| uint32_t firstIndex, | |
| int32_t vertexOffset, | |
| uint32_t firstInstance); | |
| bool PreCallValidateCmdDrawIndirect( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride); | |
| bool PreCallValidateCmdDrawIndexedIndirect( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride); | |
| bool PreCallValidateCmdDispatch( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ); | |
| bool PreCallValidateCmdDispatchIndirect( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset); | |
| bool PreCallValidateCmdCopyBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer srcBuffer, | |
| VkBuffer dstBuffer, | |
| uint32_t regionCount, | |
| const VkBufferCopy* pRegions); | |
| bool PreCallValidateCmdCopyImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkImageCopy* pRegions); | |
| bool PreCallValidateCmdBlitImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkImageBlit* pRegions, | |
| VkFilter filter); | |
| bool PreCallValidateCmdCopyBufferToImage( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer srcBuffer, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkBufferImageCopy* pRegions); | |
| bool PreCallValidateCmdCopyImageToBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkBuffer dstBuffer, | |
| uint32_t regionCount, | |
| const VkBufferImageCopy* pRegions); | |
| bool PreCallValidateCmdUpdateBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer dstBuffer, | |
| VkDeviceSize dstOffset, | |
| VkDeviceSize dataSize, | |
| const void* pData); | |
| bool PreCallValidateCmdFillBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer dstBuffer, | |
| VkDeviceSize dstOffset, | |
| VkDeviceSize size, | |
| uint32_t data); | |
| bool PreCallValidateCmdClearColorImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage image, | |
| VkImageLayout imageLayout, | |
| const VkClearColorValue* pColor, | |
| uint32_t rangeCount, | |
| const VkImageSubresourceRange* pRanges); | |
| bool PreCallValidateCmdClearDepthStencilImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage image, | |
| VkImageLayout imageLayout, | |
| const VkClearDepthStencilValue* pDepthStencil, | |
| uint32_t rangeCount, | |
| const VkImageSubresourceRange* pRanges); | |
| bool PreCallValidateCmdClearAttachments( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t attachmentCount, | |
| const VkClearAttachment* pAttachments, | |
| uint32_t rectCount, | |
| const VkClearRect* pRects); | |
| bool PreCallValidateCmdResolveImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkImageResolve* pRegions); | |
| bool PreCallValidateCmdSetEvent( | |
| VkCommandBuffer commandBuffer, | |
| VkEvent event, | |
| VkPipelineStageFlags stageMask); | |
| bool PreCallValidateCmdResetEvent( | |
| VkCommandBuffer commandBuffer, | |
| VkEvent event, | |
| VkPipelineStageFlags stageMask); | |
| 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); | |
| 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); | |
| bool PreCallValidateCmdBeginQuery( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t query, | |
| VkQueryControlFlags flags); | |
| bool PreCallValidateCmdEndQuery( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t query); | |
| bool PreCallValidateCmdResetQueryPool( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount); | |
| bool PreCallValidateCmdWriteTimestamp( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineStageFlagBits pipelineStage, | |
| VkQueryPool queryPool, | |
| uint32_t query); | |
| bool PreCallValidateCmdCopyQueryPoolResults( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| VkBuffer dstBuffer, | |
| VkDeviceSize dstOffset, | |
| VkDeviceSize stride, | |
| VkQueryResultFlags flags); | |
| bool PreCallValidateCmdPushConstants( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineLayout layout, | |
| VkShaderStageFlags stageFlags, | |
| uint32_t offset, | |
| uint32_t size, | |
| const void* pValues); | |
| bool PreCallValidateCmdBeginRenderPass( | |
| VkCommandBuffer commandBuffer, | |
| const VkRenderPassBeginInfo* pRenderPassBegin, | |
| VkSubpassContents contents); | |
| bool PreCallValidateCmdNextSubpass( | |
| VkCommandBuffer commandBuffer, | |
| VkSubpassContents contents); | |
| bool PreCallValidateCmdEndRenderPass( | |
| VkCommandBuffer commandBuffer); | |
| bool PreCallValidateCmdExecuteCommands( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t commandBufferCount, | |
| const VkCommandBuffer* pCommandBuffers); | |
| bool PreCallValidateBindBufferMemory2( | |
| VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindBufferMemoryInfo* pBindInfos); | |
| bool PreCallValidateBindImageMemory2( | |
| VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindImageMemoryInfo* pBindInfos); | |
| bool PreCallValidateGetDeviceGroupPeerMemoryFeatures( | |
| VkDevice device, | |
| uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); | |
| bool PreCallValidateCmdSetDeviceMask( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t deviceMask); | |
| bool PreCallValidateCmdDispatchBase( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t baseGroupX, | |
| uint32_t baseGroupY, | |
| uint32_t baseGroupZ, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ); | |
| bool PreCallValidateEnumeratePhysicalDeviceGroups( | |
| VkInstance instance, | |
| uint32_t* pPhysicalDeviceGroupCount, | |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); | |
| bool PreCallValidateGetImageMemoryRequirements2( | |
| VkDevice device, | |
| const VkImageMemoryRequirementsInfo2* pInfo, | |
| VkMemoryRequirements2* pMemoryRequirements); | |
| bool PreCallValidateGetBufferMemoryRequirements2( | |
| VkDevice device, | |
| const VkBufferMemoryRequirementsInfo2* pInfo, | |
| VkMemoryRequirements2* pMemoryRequirements); | |
| bool PreCallValidateGetImageSparseMemoryRequirements2( | |
| VkDevice device, | |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, | |
| uint32_t* pSparseMemoryRequirementCount, | |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); | |
| bool PreCallValidateGetPhysicalDeviceFeatures2( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceFeatures2* pFeatures); | |
| bool PreCallValidateGetPhysicalDeviceProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceProperties2* pProperties); | |
| bool PreCallValidateGetPhysicalDeviceFormatProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkFormatProperties2* pFormatProperties); | |
| bool PreCallValidateGetPhysicalDeviceImageFormatProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, | |
| VkImageFormatProperties2* pImageFormatProperties); | |
| bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pQueueFamilyPropertyCount, | |
| VkQueueFamilyProperties2* pQueueFamilyProperties); | |
| bool PreCallValidateGetPhysicalDeviceMemoryProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties); | |
| bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, | |
| uint32_t* pPropertyCount, | |
| VkSparseImageFormatProperties2* pProperties); | |
| bool PreCallValidateTrimCommandPool( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| VkCommandPoolTrimFlags flags); | |
| bool PreCallValidateGetDeviceQueue2( | |
| VkDevice device, | |
| const VkDeviceQueueInfo2* pQueueInfo, | |
| VkQueue* pQueue); | |
| void PostCallRecordGetDeviceQueue2( | |
| VkDevice device, | |
| const VkDeviceQueueInfo2* pQueueInfo, | |
| VkQueue* pQueue); | |
| bool PreCallValidateCreateSamplerYcbcrConversion( | |
| VkDevice device, | |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSamplerYcbcrConversion* pYcbcrConversion); | |
| void PostCallRecordCreateSamplerYcbcrConversion( | |
| VkDevice device, | |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSamplerYcbcrConversion* pYcbcrConversion, | |
| VkResult result); | |
| bool PreCallValidateDestroySamplerYcbcrConversion( | |
| VkDevice device, | |
| VkSamplerYcbcrConversion ycbcrConversion, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroySamplerYcbcrConversion( | |
| VkDevice device, | |
| VkSamplerYcbcrConversion ycbcrConversion, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateDescriptorUpdateTemplate( | |
| VkDevice device, | |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); | |
| void PostCallRecordCreateDescriptorUpdateTemplate( | |
| VkDevice device, | |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, | |
| VkResult result); | |
| bool PreCallValidateDestroyDescriptorUpdateTemplate( | |
| VkDevice device, | |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyDescriptorUpdateTemplate( | |
| VkDevice device, | |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateUpdateDescriptorSetWithTemplate( | |
| VkDevice device, | |
| VkDescriptorSet descriptorSet, | |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const void* pData); | |
| bool PreCallValidateGetPhysicalDeviceExternalBufferProperties( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, | |
| VkExternalBufferProperties* pExternalBufferProperties); | |
| bool PreCallValidateGetPhysicalDeviceExternalFenceProperties( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, | |
| VkExternalFenceProperties* pExternalFenceProperties); | |
| bool PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, | |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties); | |
| bool PreCallValidateGetDescriptorSetLayoutSupport( | |
| VkDevice device, | |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, | |
| VkDescriptorSetLayoutSupport* pSupport); | |
| bool PreCallValidateDestroySurfaceKHR( | |
| VkInstance instance, | |
| VkSurfaceKHR surface, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroySurfaceKHR( | |
| VkInstance instance, | |
| VkSurfaceKHR surface, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetPhysicalDeviceSurfaceSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| VkSurfaceKHR surface, | |
| VkBool32* pSupported); | |
| bool PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); | |
| bool PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| uint32_t* pSurfaceFormatCount, | |
| VkSurfaceFormatKHR* pSurfaceFormats); | |
| bool PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| uint32_t* pPresentModeCount, | |
| VkPresentModeKHR* pPresentModes); | |
| bool PreCallValidateCreateSwapchainKHR( | |
| VkDevice device, | |
| const VkSwapchainCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSwapchainKHR* pSwapchain); | |
| void PostCallRecordCreateSwapchainKHR( | |
| VkDevice device, | |
| const VkSwapchainCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSwapchainKHR* pSwapchain, | |
| VkResult result); | |
| bool PreCallValidateDestroySwapchainKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroySwapchainKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetSwapchainImagesKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint32_t* pSwapchainImageCount, | |
| VkImage* pSwapchainImages); | |
| void PostCallRecordGetSwapchainImagesKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint32_t* pSwapchainImageCount, | |
| VkImage* pSwapchainImages, | |
| VkResult result); | |
| bool PreCallValidateAcquireNextImageKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint64_t timeout, | |
| VkSemaphore semaphore, | |
| VkFence fence, | |
| uint32_t* pImageIndex); | |
| bool PreCallValidateQueuePresentKHR( | |
| VkQueue queue, | |
| const VkPresentInfoKHR* pPresentInfo); | |
| bool PreCallValidateGetDeviceGroupPresentCapabilitiesKHR( | |
| VkDevice device, | |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); | |
| bool PreCallValidateGetDeviceGroupSurfacePresentModesKHR( | |
| VkDevice device, | |
| VkSurfaceKHR surface, | |
| VkDeviceGroupPresentModeFlagsKHR* pModes); | |
| bool PreCallValidateGetPhysicalDevicePresentRectanglesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| uint32_t* pRectCount, | |
| VkRect2D* pRects); | |
| bool PreCallValidateAcquireNextImage2KHR( | |
| VkDevice device, | |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, | |
| uint32_t* pImageIndex); | |
| bool PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkDisplayPropertiesKHR* pProperties); | |
| bool PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkDisplayPlanePropertiesKHR* pProperties); | |
| bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t planeIndex, | |
| uint32_t* pDisplayCount, | |
| VkDisplayKHR* pDisplays); | |
| void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t planeIndex, | |
| uint32_t* pDisplayCount, | |
| VkDisplayKHR* pDisplays, | |
| VkResult result); | |
| bool PreCallValidateGetDisplayModePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display, | |
| uint32_t* pPropertyCount, | |
| VkDisplayModePropertiesKHR* pProperties); | |
| bool PreCallValidateCreateDisplayModeKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display, | |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDisplayModeKHR* pMode); | |
| void PostCallRecordCreateDisplayModeKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display, | |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDisplayModeKHR* pMode, | |
| VkResult result); | |
| bool PreCallValidateGetDisplayPlaneCapabilitiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayModeKHR mode, | |
| uint32_t planeIndex, | |
| VkDisplayPlaneCapabilitiesKHR* pCapabilities); | |
| bool PreCallValidateCreateDisplayPlaneSurfaceKHR( | |
| VkInstance instance, | |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateDisplayPlaneSurfaceKHR( | |
| VkInstance instance, | |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| bool PreCallValidateCreateSharedSwapchainsKHR( | |
| VkDevice device, | |
| uint32_t swapchainCount, | |
| const VkSwapchainCreateInfoKHR* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSwapchainKHR* pSwapchains); | |
| void PostCallRecordCreateSharedSwapchainsKHR( | |
| VkDevice device, | |
| uint32_t swapchainCount, | |
| const VkSwapchainCreateInfoKHR* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSwapchainKHR* pSwapchains, | |
| VkResult result); | |
| #ifdef VK_USE_PLATFORM_XLIB_KHR | |
| bool PreCallValidateCreateXlibSurfaceKHR( | |
| VkInstance instance, | |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateXlibSurfaceKHR( | |
| VkInstance instance, | |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_XLIB_KHR | |
| #ifdef VK_USE_PLATFORM_XLIB_KHR | |
| bool PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| Display* dpy, | |
| VisualID visualID); | |
| #endif // VK_USE_PLATFORM_XLIB_KHR | |
| #ifdef VK_USE_PLATFORM_XCB_KHR | |
| bool PreCallValidateCreateXcbSurfaceKHR( | |
| VkInstance instance, | |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateXcbSurfaceKHR( | |
| VkInstance instance, | |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_XCB_KHR | |
| #ifdef VK_USE_PLATFORM_XCB_KHR | |
| bool PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| xcb_connection_t* connection, | |
| xcb_visualid_t visual_id); | |
| #endif // VK_USE_PLATFORM_XCB_KHR | |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR | |
| bool PreCallValidateCreateWaylandSurfaceKHR( | |
| VkInstance instance, | |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateWaylandSurfaceKHR( | |
| VkInstance instance, | |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_WAYLAND_KHR | |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR | |
| bool PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| struct wl_display* display); | |
| #endif // VK_USE_PLATFORM_WAYLAND_KHR | |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR | |
| bool PreCallValidateCreateAndroidSurfaceKHR( | |
| VkInstance instance, | |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateAndroidSurfaceKHR( | |
| VkInstance instance, | |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_ANDROID_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateCreateWin32SurfaceKHR( | |
| VkInstance instance, | |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateWin32SurfaceKHR( | |
| VkInstance instance, | |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetPhysicalDeviceFeatures2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceFeatures2* pFeatures); | |
| bool PreCallValidateGetPhysicalDeviceProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceProperties2* pProperties); | |
| bool PreCallValidateGetPhysicalDeviceFormatProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkFormatProperties2* pFormatProperties); | |
| bool PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, | |
| VkImageFormatProperties2* pImageFormatProperties); | |
| bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pQueueFamilyPropertyCount, | |
| VkQueueFamilyProperties2* pQueueFamilyProperties); | |
| bool PreCallValidateGetPhysicalDeviceMemoryProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties); | |
| bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, | |
| uint32_t* pPropertyCount, | |
| VkSparseImageFormatProperties2* pProperties); | |
| bool PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR( | |
| VkDevice device, | |
| uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); | |
| bool PreCallValidateCmdSetDeviceMaskKHR( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t deviceMask); | |
| bool PreCallValidateCmdDispatchBaseKHR( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t baseGroupX, | |
| uint32_t baseGroupY, | |
| uint32_t baseGroupZ, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ); | |
| bool PreCallValidateTrimCommandPoolKHR( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| VkCommandPoolTrimFlags flags); | |
| bool PreCallValidateEnumeratePhysicalDeviceGroupsKHR( | |
| VkInstance instance, | |
| uint32_t* pPhysicalDeviceGroupCount, | |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); | |
| bool PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, | |
| VkExternalBufferProperties* pExternalBufferProperties); | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetMemoryWin32HandleKHR( | |
| VkDevice device, | |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetMemoryWin32HandlePropertiesKHR( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBits handleType, | |
| HANDLE handle, | |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetMemoryFdKHR( | |
| VkDevice device, | |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, | |
| int* pFd); | |
| bool PreCallValidateGetMemoryFdPropertiesKHR( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBits handleType, | |
| int fd, | |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties); | |
| bool PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, | |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties); | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateImportSemaphoreWin32HandleKHR( | |
| VkDevice device, | |
| const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetSemaphoreWin32HandleKHR( | |
| VkDevice device, | |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateImportSemaphoreFdKHR( | |
| VkDevice device, | |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); | |
| bool PreCallValidateGetSemaphoreFdKHR( | |
| VkDevice device, | |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, | |
| int* pFd); | |
| bool PreCallValidateCmdPushDescriptorSetKHR( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineBindPoint pipelineBindPoint, | |
| VkPipelineLayout layout, | |
| uint32_t set, | |
| uint32_t descriptorWriteCount, | |
| const VkWriteDescriptorSet* pDescriptorWrites); | |
| bool PreCallValidateCmdPushDescriptorSetWithTemplateKHR( | |
| VkCommandBuffer commandBuffer, | |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, | |
| VkPipelineLayout layout, | |
| uint32_t set, | |
| const void* pData); | |
| bool PreCallValidateCreateDescriptorUpdateTemplateKHR( | |
| VkDevice device, | |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); | |
| void PostCallRecordCreateDescriptorUpdateTemplateKHR( | |
| VkDevice device, | |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, | |
| VkResult result); | |
| bool PreCallValidateDestroyDescriptorUpdateTemplateKHR( | |
| VkDevice device, | |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyDescriptorUpdateTemplateKHR( | |
| VkDevice device, | |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateUpdateDescriptorSetWithTemplateKHR( | |
| VkDevice device, | |
| VkDescriptorSet descriptorSet, | |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, | |
| const void* pData); | |
| bool PreCallValidateCreateRenderPass2KHR( | |
| VkDevice device, | |
| const VkRenderPassCreateInfo2KHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkRenderPass* pRenderPass); | |
| void PostCallRecordCreateRenderPass2KHR( | |
| VkDevice device, | |
| const VkRenderPassCreateInfo2KHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkRenderPass* pRenderPass, | |
| VkResult result); | |
| bool PreCallValidateCmdBeginRenderPass2KHR( | |
| VkCommandBuffer commandBuffer, | |
| const VkRenderPassBeginInfo* pRenderPassBegin, | |
| const VkSubpassBeginInfoKHR* pSubpassBeginInfo); | |
| bool PreCallValidateCmdNextSubpass2KHR( | |
| VkCommandBuffer commandBuffer, | |
| const VkSubpassBeginInfoKHR* pSubpassBeginInfo, | |
| const VkSubpassEndInfoKHR* pSubpassEndInfo); | |
| bool PreCallValidateCmdEndRenderPass2KHR( | |
| VkCommandBuffer commandBuffer, | |
| const VkSubpassEndInfoKHR* pSubpassEndInfo); | |
| bool PreCallValidateGetSwapchainStatusKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain); | |
| bool PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, | |
| VkExternalFenceProperties* pExternalFenceProperties); | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateImportFenceWin32HandleKHR( | |
| VkDevice device, | |
| const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetFenceWin32HandleKHR( | |
| VkDevice device, | |
| const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateImportFenceFdKHR( | |
| VkDevice device, | |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo); | |
| bool PreCallValidateGetFenceFdKHR( | |
| VkDevice device, | |
| const VkFenceGetFdInfoKHR* pGetFdInfo, | |
| int* pFd); | |
| bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, | |
| VkSurfaceCapabilities2KHR* pSurfaceCapabilities); | |
| bool PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, | |
| uint32_t* pSurfaceFormatCount, | |
| VkSurfaceFormat2KHR* pSurfaceFormats); | |
| bool PreCallValidateGetPhysicalDeviceDisplayProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkDisplayProperties2KHR* pProperties); | |
| bool PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkDisplayPlaneProperties2KHR* pProperties); | |
| bool PreCallValidateGetDisplayModeProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display, | |
| uint32_t* pPropertyCount, | |
| VkDisplayModeProperties2KHR* pProperties); | |
| bool PreCallValidateGetDisplayPlaneCapabilities2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, | |
| VkDisplayPlaneCapabilities2KHR* pCapabilities); | |
| bool PreCallValidateGetImageMemoryRequirements2KHR( | |
| VkDevice device, | |
| const VkImageMemoryRequirementsInfo2* pInfo, | |
| VkMemoryRequirements2* pMemoryRequirements); | |
| bool PreCallValidateGetBufferMemoryRequirements2KHR( | |
| VkDevice device, | |
| const VkBufferMemoryRequirementsInfo2* pInfo, | |
| VkMemoryRequirements2* pMemoryRequirements); | |
| bool PreCallValidateGetImageSparseMemoryRequirements2KHR( | |
| VkDevice device, | |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, | |
| uint32_t* pSparseMemoryRequirementCount, | |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); | |
| bool PreCallValidateCreateSamplerYcbcrConversionKHR( | |
| VkDevice device, | |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSamplerYcbcrConversion* pYcbcrConversion); | |
| void PostCallRecordCreateSamplerYcbcrConversionKHR( | |
| VkDevice device, | |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSamplerYcbcrConversion* pYcbcrConversion, | |
| VkResult result); | |
| bool PreCallValidateDestroySamplerYcbcrConversionKHR( | |
| VkDevice device, | |
| VkSamplerYcbcrConversion ycbcrConversion, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroySamplerYcbcrConversionKHR( | |
| VkDevice device, | |
| VkSamplerYcbcrConversion ycbcrConversion, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateBindBufferMemory2KHR( | |
| VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindBufferMemoryInfo* pBindInfos); | |
| bool PreCallValidateBindImageMemory2KHR( | |
| VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindImageMemoryInfo* pBindInfos); | |
| bool PreCallValidateGetDescriptorSetLayoutSupportKHR( | |
| VkDevice device, | |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, | |
| VkDescriptorSetLayoutSupport* pSupport); | |
| bool PreCallValidateCmdDrawIndirectCountKHR( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkBuffer countBuffer, | |
| VkDeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride); | |
| bool PreCallValidateCmdDrawIndexedIndirectCountKHR( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkBuffer countBuffer, | |
| VkDeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride); | |
| bool PreCallValidateGetPipelineExecutablePropertiesKHR( | |
| VkDevice device, | |
| const VkPipelineInfoKHR* pPipelineInfo, | |
| uint32_t* pExecutableCount, | |
| VkPipelineExecutablePropertiesKHR* pProperties); | |
| bool PreCallValidateGetPipelineExecutableStatisticsKHR( | |
| VkDevice device, | |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, | |
| uint32_t* pStatisticCount, | |
| VkPipelineExecutableStatisticKHR* pStatistics); | |
| bool PreCallValidateGetPipelineExecutableInternalRepresentationsKHR( | |
| VkDevice device, | |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, | |
| uint32_t* pInternalRepresentationCount, | |
| VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); | |
| bool PreCallValidateCreateDebugReportCallbackEXT( | |
| VkInstance instance, | |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDebugReportCallbackEXT* pCallback); | |
| void PostCallRecordCreateDebugReportCallbackEXT( | |
| VkInstance instance, | |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDebugReportCallbackEXT* pCallback, | |
| VkResult result); | |
| bool PreCallValidateDestroyDebugReportCallbackEXT( | |
| VkInstance instance, | |
| VkDebugReportCallbackEXT callback, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyDebugReportCallbackEXT( | |
| VkInstance instance, | |
| VkDebugReportCallbackEXT callback, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateDebugReportMessageEXT( | |
| VkInstance instance, | |
| VkDebugReportFlagsEXT flags, | |
| VkDebugReportObjectTypeEXT objectType, | |
| uint64_t object, | |
| size_t location, | |
| int32_t messageCode, | |
| const char* pLayerPrefix, | |
| const char* pMessage); | |
| bool PreCallValidateDebugMarkerSetObjectTagEXT( | |
| VkDevice device, | |
| const VkDebugMarkerObjectTagInfoEXT* pTagInfo); | |
| bool PreCallValidateDebugMarkerSetObjectNameEXT( | |
| VkDevice device, | |
| const VkDebugMarkerObjectNameInfoEXT* pNameInfo); | |
| bool PreCallValidateCmdDebugMarkerBeginEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); | |
| bool PreCallValidateCmdDebugMarkerEndEXT( | |
| VkCommandBuffer commandBuffer); | |
| bool PreCallValidateCmdDebugMarkerInsertEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); | |
| bool PreCallValidateCmdBindTransformFeedbackBuffersEXT( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VkBuffer* pBuffers, | |
| const VkDeviceSize* pOffsets, | |
| const VkDeviceSize* pSizes); | |
| bool PreCallValidateCmdBeginTransformFeedbackEXT( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstCounterBuffer, | |
| uint32_t counterBufferCount, | |
| const VkBuffer* pCounterBuffers, | |
| const VkDeviceSize* pCounterBufferOffsets); | |
| bool PreCallValidateCmdEndTransformFeedbackEXT( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstCounterBuffer, | |
| uint32_t counterBufferCount, | |
| const VkBuffer* pCounterBuffers, | |
| const VkDeviceSize* pCounterBufferOffsets); | |
| bool PreCallValidateCmdBeginQueryIndexedEXT( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t query, | |
| VkQueryControlFlags flags, | |
| uint32_t index); | |
| bool PreCallValidateCmdEndQueryIndexedEXT( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t query, | |
| uint32_t index); | |
| bool PreCallValidateCmdDrawIndirectByteCountEXT( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t instanceCount, | |
| uint32_t firstInstance, | |
| VkBuffer counterBuffer, | |
| VkDeviceSize counterBufferOffset, | |
| uint32_t counterOffset, | |
| uint32_t vertexStride); | |
| bool PreCallValidateGetImageViewHandleNVX( | |
| VkDevice device, | |
| const VkImageViewHandleInfoNVX* pInfo); | |
| bool PreCallValidateCmdDrawIndirectCountAMD( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkBuffer countBuffer, | |
| VkDeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride); | |
| bool PreCallValidateCmdDrawIndexedIndirectCountAMD( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkBuffer countBuffer, | |
| VkDeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride); | |
| bool PreCallValidateGetShaderInfoAMD( | |
| VkDevice device, | |
| VkPipeline pipeline, | |
| VkShaderStageFlagBits shaderStage, | |
| VkShaderInfoTypeAMD infoType, | |
| size_t* pInfoSize, | |
| void* pInfo); | |
| #ifdef VK_USE_PLATFORM_GGP | |
| bool PreCallValidateCreateStreamDescriptorSurfaceGGP( | |
| VkInstance instance, | |
| const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateStreamDescriptorSurfaceGGP( | |
| VkInstance instance, | |
| const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_GGP | |
| bool PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkImageType type, | |
| VkImageTiling tiling, | |
| VkImageUsageFlags usage, | |
| VkImageCreateFlags flags, | |
| VkExternalMemoryHandleTypeFlagsNV externalHandleType, | |
| VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetMemoryWin32HandleNV( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| VkExternalMemoryHandleTypeFlagsNV handleType, | |
| HANDLE* pHandle); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_VI_NN | |
| bool PreCallValidateCreateViSurfaceNN( | |
| VkInstance instance, | |
| const VkViSurfaceCreateInfoNN* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateViSurfaceNN( | |
| VkInstance instance, | |
| const VkViSurfaceCreateInfoNN* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_VI_NN | |
| bool PreCallValidateCmdBeginConditionalRenderingEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); | |
| bool PreCallValidateCmdEndConditionalRenderingEXT( | |
| VkCommandBuffer commandBuffer); | |
| bool PreCallValidateCmdProcessCommandsNVX( | |
| VkCommandBuffer commandBuffer, | |
| const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); | |
| bool PreCallValidateCmdReserveSpaceForCommandsNVX( | |
| VkCommandBuffer commandBuffer, | |
| const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); | |
| bool PreCallValidateCreateIndirectCommandsLayoutNVX( | |
| VkDevice device, | |
| const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); | |
| void PostCallRecordCreateIndirectCommandsLayoutNVX( | |
| VkDevice device, | |
| const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout, | |
| VkResult result); | |
| bool PreCallValidateDestroyIndirectCommandsLayoutNVX( | |
| VkDevice device, | |
| VkIndirectCommandsLayoutNVX indirectCommandsLayout, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyIndirectCommandsLayoutNVX( | |
| VkDevice device, | |
| VkIndirectCommandsLayoutNVX indirectCommandsLayout, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateCreateObjectTableNVX( | |
| VkDevice device, | |
| const VkObjectTableCreateInfoNVX* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkObjectTableNVX* pObjectTable); | |
| void PostCallRecordCreateObjectTableNVX( | |
| VkDevice device, | |
| const VkObjectTableCreateInfoNVX* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkObjectTableNVX* pObjectTable, | |
| VkResult result); | |
| bool PreCallValidateDestroyObjectTableNVX( | |
| VkDevice device, | |
| VkObjectTableNVX objectTable, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyObjectTableNVX( | |
| VkDevice device, | |
| VkObjectTableNVX objectTable, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateRegisterObjectsNVX( | |
| VkDevice device, | |
| VkObjectTableNVX objectTable, | |
| uint32_t objectCount, | |
| const VkObjectTableEntryNVX* const* ppObjectTableEntries, | |
| const uint32_t* pObjectIndices); | |
| bool PreCallValidateUnregisterObjectsNVX( | |
| VkDevice device, | |
| VkObjectTableNVX objectTable, | |
| uint32_t objectCount, | |
| const VkObjectEntryTypeNVX* pObjectEntryTypes, | |
| const uint32_t* pObjectIndices); | |
| bool PreCallValidateGetPhysicalDeviceGeneratedCommandsPropertiesNVX( | |
| VkPhysicalDevice physicalDevice, | |
| VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, | |
| VkDeviceGeneratedCommandsLimitsNVX* pLimits); | |
| bool PreCallValidateCmdSetViewportWScalingNV( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VkViewportWScalingNV* pViewportWScalings); | |
| bool PreCallValidateReleaseDisplayEXT( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display); | |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT | |
| bool PreCallValidateAcquireXlibDisplayEXT( | |
| VkPhysicalDevice physicalDevice, | |
| Display* dpy, | |
| VkDisplayKHR display); | |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT | |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT | |
| bool PreCallValidateGetRandROutputDisplayEXT( | |
| VkPhysicalDevice physicalDevice, | |
| Display* dpy, | |
| RROutput rrOutput, | |
| VkDisplayKHR* pDisplay); | |
| void PostCallRecordGetRandROutputDisplayEXT( | |
| VkPhysicalDevice physicalDevice, | |
| Display* dpy, | |
| RROutput rrOutput, | |
| VkDisplayKHR* pDisplay, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT | |
| bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| VkSurfaceCapabilities2EXT* pSurfaceCapabilities); | |
| bool PreCallValidateDisplayPowerControlEXT( | |
| VkDevice device, | |
| VkDisplayKHR display, | |
| const VkDisplayPowerInfoEXT* pDisplayPowerInfo); | |
| bool PreCallValidateRegisterDeviceEventEXT( | |
| VkDevice device, | |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence); | |
| void PostCallRecordRegisterDeviceEventEXT( | |
| VkDevice device, | |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence, | |
| VkResult result); | |
| bool PreCallValidateRegisterDisplayEventEXT( | |
| VkDevice device, | |
| VkDisplayKHR display, | |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence); | |
| void PostCallRecordRegisterDisplayEventEXT( | |
| VkDevice device, | |
| VkDisplayKHR display, | |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence, | |
| VkResult result); | |
| bool PreCallValidateGetSwapchainCounterEXT( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| VkSurfaceCounterFlagBitsEXT counter, | |
| uint64_t* pCounterValue); | |
| bool PreCallValidateGetRefreshCycleDurationGOOGLE( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); | |
| bool PreCallValidateGetPastPresentationTimingGOOGLE( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint32_t* pPresentationTimingCount, | |
| VkPastPresentationTimingGOOGLE* pPresentationTimings); | |
| bool PreCallValidateCmdSetDiscardRectangleEXT( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstDiscardRectangle, | |
| uint32_t discardRectangleCount, | |
| const VkRect2D* pDiscardRectangles); | |
| bool PreCallValidateSetHdrMetadataEXT( | |
| VkDevice device, | |
| uint32_t swapchainCount, | |
| const VkSwapchainKHR* pSwapchains, | |
| const VkHdrMetadataEXT* pMetadata); | |
| #ifdef VK_USE_PLATFORM_IOS_MVK | |
| bool PreCallValidateCreateIOSSurfaceMVK( | |
| VkInstance instance, | |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateIOSSurfaceMVK( | |
| VkInstance instance, | |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_IOS_MVK | |
| #ifdef VK_USE_PLATFORM_MACOS_MVK | |
| bool PreCallValidateCreateMacOSSurfaceMVK( | |
| VkInstance instance, | |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateMacOSSurfaceMVK( | |
| VkInstance instance, | |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_MACOS_MVK | |
| bool PreCallValidateSetDebugUtilsObjectNameEXT( | |
| VkDevice device, | |
| const VkDebugUtilsObjectNameInfoEXT* pNameInfo); | |
| bool PreCallValidateSetDebugUtilsObjectTagEXT( | |
| VkDevice device, | |
| const VkDebugUtilsObjectTagInfoEXT* pTagInfo); | |
| bool PreCallValidateQueueBeginDebugUtilsLabelEXT( | |
| VkQueue queue, | |
| const VkDebugUtilsLabelEXT* pLabelInfo); | |
| bool PreCallValidateQueueEndDebugUtilsLabelEXT( | |
| VkQueue queue); | |
| bool PreCallValidateQueueInsertDebugUtilsLabelEXT( | |
| VkQueue queue, | |
| const VkDebugUtilsLabelEXT* pLabelInfo); | |
| bool PreCallValidateCmdBeginDebugUtilsLabelEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkDebugUtilsLabelEXT* pLabelInfo); | |
| bool PreCallValidateCmdEndDebugUtilsLabelEXT( | |
| VkCommandBuffer commandBuffer); | |
| bool PreCallValidateCmdInsertDebugUtilsLabelEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkDebugUtilsLabelEXT* pLabelInfo); | |
| bool PreCallValidateCreateDebugUtilsMessengerEXT( | |
| VkInstance instance, | |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDebugUtilsMessengerEXT* pMessenger); | |
| void PostCallRecordCreateDebugUtilsMessengerEXT( | |
| VkInstance instance, | |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDebugUtilsMessengerEXT* pMessenger, | |
| VkResult result); | |
| bool PreCallValidateDestroyDebugUtilsMessengerEXT( | |
| VkInstance instance, | |
| VkDebugUtilsMessengerEXT messenger, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyDebugUtilsMessengerEXT( | |
| VkInstance instance, | |
| VkDebugUtilsMessengerEXT messenger, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateSubmitDebugUtilsMessageEXT( | |
| VkInstance instance, | |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, | |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, | |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); | |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR | |
| bool PreCallValidateGetAndroidHardwareBufferPropertiesANDROID( | |
| VkDevice device, | |
| const struct AHardwareBuffer* buffer, | |
| VkAndroidHardwareBufferPropertiesANDROID* pProperties); | |
| #endif // VK_USE_PLATFORM_ANDROID_KHR | |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR | |
| bool PreCallValidateGetMemoryAndroidHardwareBufferANDROID( | |
| VkDevice device, | |
| const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, | |
| struct AHardwareBuffer** pBuffer); | |
| #endif // VK_USE_PLATFORM_ANDROID_KHR | |
| bool PreCallValidateCmdSetSampleLocationsEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo); | |
| bool PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT( | |
| VkPhysicalDevice physicalDevice, | |
| VkSampleCountFlagBits samples, | |
| VkMultisamplePropertiesEXT* pMultisampleProperties); | |
| bool PreCallValidateGetImageDrmFormatModifierPropertiesEXT( | |
| VkDevice device, | |
| VkImage image, | |
| VkImageDrmFormatModifierPropertiesEXT* pProperties); | |
| bool PreCallValidateCreateValidationCacheEXT( | |
| VkDevice device, | |
| const VkValidationCacheCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkValidationCacheEXT* pValidationCache); | |
| void PostCallRecordCreateValidationCacheEXT( | |
| VkDevice device, | |
| const VkValidationCacheCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkValidationCacheEXT* pValidationCache, | |
| VkResult result); | |
| bool PreCallValidateDestroyValidationCacheEXT( | |
| VkDevice device, | |
| VkValidationCacheEXT validationCache, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyValidationCacheEXT( | |
| VkDevice device, | |
| VkValidationCacheEXT validationCache, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateMergeValidationCachesEXT( | |
| VkDevice device, | |
| VkValidationCacheEXT dstCache, | |
| uint32_t srcCacheCount, | |
| const VkValidationCacheEXT* pSrcCaches); | |
| bool PreCallValidateGetValidationCacheDataEXT( | |
| VkDevice device, | |
| VkValidationCacheEXT validationCache, | |
| size_t* pDataSize, | |
| void* pData); | |
| bool PreCallValidateCmdBindShadingRateImageNV( | |
| VkCommandBuffer commandBuffer, | |
| VkImageView imageView, | |
| VkImageLayout imageLayout); | |
| bool PreCallValidateCmdSetViewportShadingRatePaletteNV( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VkShadingRatePaletteNV* pShadingRatePalettes); | |
| bool PreCallValidateCmdSetCoarseSampleOrderNV( | |
| VkCommandBuffer commandBuffer, | |
| VkCoarseSampleOrderTypeNV sampleOrderType, | |
| uint32_t customSampleOrderCount, | |
| const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); | |
| bool PreCallValidateCreateAccelerationStructureNV( | |
| VkDevice device, | |
| const VkAccelerationStructureCreateInfoNV* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkAccelerationStructureNV* pAccelerationStructure); | |
| void PostCallRecordCreateAccelerationStructureNV( | |
| VkDevice device, | |
| const VkAccelerationStructureCreateInfoNV* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkAccelerationStructureNV* pAccelerationStructure, | |
| VkResult result); | |
| bool PreCallValidateDestroyAccelerationStructureNV( | |
| VkDevice device, | |
| VkAccelerationStructureNV accelerationStructure, | |
| const VkAllocationCallbacks* pAllocator); | |
| void PreCallRecordDestroyAccelerationStructureNV( | |
| VkDevice device, | |
| VkAccelerationStructureNV accelerationStructure, | |
| const VkAllocationCallbacks* pAllocator); | |
| bool PreCallValidateGetAccelerationStructureMemoryRequirementsNV( | |
| VkDevice device, | |
| const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, | |
| VkMemoryRequirements2KHR* pMemoryRequirements); | |
| bool PreCallValidateBindAccelerationStructureMemoryNV( | |
| VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); | |
| bool PreCallValidateCmdBuildAccelerationStructureNV( | |
| VkCommandBuffer commandBuffer, | |
| const VkAccelerationStructureInfoNV* pInfo, | |
| VkBuffer instanceData, | |
| VkDeviceSize instanceOffset, | |
| VkBool32 update, | |
| VkAccelerationStructureNV dst, | |
| VkAccelerationStructureNV src, | |
| VkBuffer scratch, | |
| VkDeviceSize scratchOffset); | |
| bool PreCallValidateCmdCopyAccelerationStructureNV( | |
| VkCommandBuffer commandBuffer, | |
| VkAccelerationStructureNV dst, | |
| VkAccelerationStructureNV src, | |
| VkCopyAccelerationStructureModeNV mode); | |
| 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); | |
| bool PreCallValidateCreateRayTracingPipelinesNV( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkRayTracingPipelineCreateInfoNV* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines); | |
| void PostCallRecordCreateRayTracingPipelinesNV( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkRayTracingPipelineCreateInfoNV* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines, | |
| VkResult result); | |
| bool PreCallValidateGetRayTracingShaderGroupHandlesNV( | |
| VkDevice device, | |
| VkPipeline pipeline, | |
| uint32_t firstGroup, | |
| uint32_t groupCount, | |
| size_t dataSize, | |
| void* pData); | |
| bool PreCallValidateGetAccelerationStructureHandleNV( | |
| VkDevice device, | |
| VkAccelerationStructureNV accelerationStructure, | |
| size_t dataSize, | |
| void* pData); | |
| bool PreCallValidateCmdWriteAccelerationStructuresPropertiesNV( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t accelerationStructureCount, | |
| const VkAccelerationStructureNV* pAccelerationStructures, | |
| VkQueryType queryType, | |
| VkQueryPool queryPool, | |
| uint32_t firstQuery); | |
| bool PreCallValidateCompileDeferredNV( | |
| VkDevice device, | |
| VkPipeline pipeline, | |
| uint32_t shader); | |
| bool PreCallValidateGetMemoryHostPointerPropertiesEXT( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBits handleType, | |
| const void* pHostPointer, | |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); | |
| bool PreCallValidateCmdWriteBufferMarkerAMD( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineStageFlagBits pipelineStage, | |
| VkBuffer dstBuffer, | |
| VkDeviceSize dstOffset, | |
| uint32_t marker); | |
| bool PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pTimeDomainCount, | |
| VkTimeDomainEXT* pTimeDomains); | |
| bool PreCallValidateGetCalibratedTimestampsEXT( | |
| VkDevice device, | |
| uint32_t timestampCount, | |
| const VkCalibratedTimestampInfoEXT* pTimestampInfos, | |
| uint64_t* pTimestamps, | |
| uint64_t* pMaxDeviation); | |
| bool PreCallValidateCmdDrawMeshTasksNV( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t taskCount, | |
| uint32_t firstTask); | |
| bool PreCallValidateCmdDrawMeshTasksIndirectNV( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride); | |
| bool PreCallValidateCmdDrawMeshTasksIndirectCountNV( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkBuffer countBuffer, | |
| VkDeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride); | |
| bool PreCallValidateCmdSetExclusiveScissorNV( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstExclusiveScissor, | |
| uint32_t exclusiveScissorCount, | |
| const VkRect2D* pExclusiveScissors); | |
| bool PreCallValidateCmdSetCheckpointNV( | |
| VkCommandBuffer commandBuffer, | |
| const void* pCheckpointMarker); | |
| bool PreCallValidateGetQueueCheckpointDataNV( | |
| VkQueue queue, | |
| uint32_t* pCheckpointDataCount, | |
| VkCheckpointDataNV* pCheckpointData); | |
| bool PreCallValidateInitializePerformanceApiINTEL( | |
| VkDevice device, | |
| const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); | |
| bool PreCallValidateUninitializePerformanceApiINTEL( | |
| VkDevice device); | |
| bool PreCallValidateCmdSetPerformanceMarkerINTEL( | |
| VkCommandBuffer commandBuffer, | |
| const VkPerformanceMarkerInfoINTEL* pMarkerInfo); | |
| bool PreCallValidateCmdSetPerformanceStreamMarkerINTEL( | |
| VkCommandBuffer commandBuffer, | |
| const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); | |
| bool PreCallValidateCmdSetPerformanceOverrideINTEL( | |
| VkCommandBuffer commandBuffer, | |
| const VkPerformanceOverrideInfoINTEL* pOverrideInfo); | |
| bool PreCallValidateAcquirePerformanceConfigurationINTEL( | |
| VkDevice device, | |
| const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, | |
| VkPerformanceConfigurationINTEL* pConfiguration); | |
| bool PreCallValidateReleasePerformanceConfigurationINTEL( | |
| VkDevice device, | |
| VkPerformanceConfigurationINTEL configuration); | |
| bool PreCallValidateQueueSetPerformanceConfigurationINTEL( | |
| VkQueue queue, | |
| VkPerformanceConfigurationINTEL configuration); | |
| bool PreCallValidateGetPerformanceParameterINTEL( | |
| VkDevice device, | |
| VkPerformanceParameterTypeINTEL parameter, | |
| VkPerformanceValueINTEL* pValue); | |
| bool PreCallValidateSetLocalDimmingAMD( | |
| VkDevice device, | |
| VkSwapchainKHR swapChain, | |
| VkBool32 localDimmingEnable); | |
| #ifdef VK_USE_PLATFORM_FUCHSIA | |
| bool PreCallValidateCreateImagePipeSurfaceFUCHSIA( | |
| VkInstance instance, | |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateImagePipeSurfaceFUCHSIA( | |
| VkInstance instance, | |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_FUCHSIA | |
| #ifdef VK_USE_PLATFORM_METAL_EXT | |
| bool PreCallValidateCreateMetalSurfaceEXT( | |
| VkInstance instance, | |
| const VkMetalSurfaceCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateMetalSurfaceEXT( | |
| VkInstance instance, | |
| const VkMetalSurfaceCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| #endif // VK_USE_PLATFORM_METAL_EXT | |
| bool PreCallValidateGetBufferDeviceAddressEXT( | |
| VkDevice device, | |
| const VkBufferDeviceAddressInfoEXT* pInfo); | |
| bool PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkCooperativeMatrixPropertiesNV* pProperties); | |
| bool PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pCombinationCount, | |
| VkFramebufferMixedSamplesCombinationNV* pCombinations); | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, | |
| uint32_t* pPresentModeCount, | |
| VkPresentModeKHR* pPresentModes); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateAcquireFullScreenExclusiveModeEXT( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateReleaseFullScreenExclusiveModeEXT( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateGetDeviceGroupSurfacePresentModes2EXT( | |
| VkDevice device, | |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, | |
| VkDeviceGroupPresentModeFlagsKHR* pModes); | |
| #endif // VK_USE_PLATFORM_WIN32_KHR | |
| bool PreCallValidateCreateHeadlessSurfaceEXT( | |
| VkInstance instance, | |
| const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface); | |
| void PostCallRecordCreateHeadlessSurfaceEXT( | |
| VkInstance instance, | |
| const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface, | |
| VkResult result); | |
| bool PreCallValidateCmdSetLineStippleEXT( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t lineStippleFactor, | |
| uint16_t lineStipplePattern); | |
| bool PreCallValidateResetQueryPoolEXT( | |
| VkDevice device, | |
| VkQueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount); | |
| void PostCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator); | |
| void PreCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); | |
| void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties); | |
| void PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers); | |
| void PreCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets); | |
| void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties); | |
| void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties); | |
| void PostCallRecordGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties, VkResult result); | |
| void PostCallRecordGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties, VkResult result); | |
| void PostCallRecordGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties, VkResult result); | |
| void PostCallRecordGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties, VkResult result); |