diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index d5ae9665e..0b151546e 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -482,10 +482,12 @@ public: IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateInstance, const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyInstance, - VkInstance instance); + VkInstance instance, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkEnumeratePhysicalDevices, VkInstance instance, @@ -511,14 +513,14 @@ public: VkImageFormatProperties* pImageFormatProperties); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceSparseImageFormatProperties, - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - uint32_t samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pNumProperties, - VkSparseImageFormatProperties* pProperties); + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + uint32_t samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceProperties, VkPhysicalDevice physicalDevice, @@ -526,7 +528,7 @@ public: IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceQueueFamilyProperties, VkPhysicalDevice physicalDevice, - uint32_t* pCount, + uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceMemoryProperties, @@ -538,753 +540,744 @@ public: IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDevice, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyDevice, - VkDevice device); + VkDevice device, + const VkAllocationCallbacks* pAllocator); // Queue functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetDeviceQueue, - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue); + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueSubmit, - VkQueue queue, - uint32_t cmdBufferCount, - const VkCommandBuffer* pCmdBuffers, - VkFence fence); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueAddMemReferences, - VkQueue queue, - uint32_t count, - const VkDeviceMemory* pMems); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueRemoveMemReferences, - VkQueue queue, - uint32_t count, - const VkDeviceMemory* pMems); + VkQueue queue, + uint32_t cmdBufferCount, + const VkSubmitInfo* pSubmits, + VkFence fence); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueWaitIdle, - VkQueue queue); + VkQueue queue); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDeviceWaitIdle, - VkDevice device); + VkDevice device); // Query pool functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateQueryPool, - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - VkQueryPool* pQueryPool); + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyQueryPool, - VkDevice device, - VkQueryPool queryPool); + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetQueryPoolResults, - VkDevice device, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - size_t* pDataSize, - void* pData, - VkQueryResultFlags flags); + VkDevice device, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); // Semaphore functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSemaphore, - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - VkSemaphore* pSemaphore); + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroySemaphore, - VkDevice device, - VkSemaphore semaphore); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueSignalSemaphore, - VkQueue queue, - VkSemaphore semaphore); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueWaitSemaphore, - VkQueue queue, - VkSemaphore semaphore); + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); // Fence functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFence, - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - VkFence* pFence); + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyFence, - VkDevice device, - VkFence fence); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetFenceStatus, - VkDevice device, - VkFence fence); + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetFences, - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetFenceStatus, + VkDevice device, + VkFence fence); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkWaitForFences, - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout); + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); // Event functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateEvent, - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - VkEvent* pEvent); + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyEvent, - VkDevice device, - VkEvent event); + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetEventStatus, - VkDevice device, - VkEvent event); + VkDevice device, + VkEvent event); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkSetEvent, - VkDevice device, - VkEvent event); + VkDevice device, + VkEvent event); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetEvent, - VkDevice device, - VkEvent event); + VkDevice device, + VkEvent event); // Memory functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocMemory, - VkDevice device, - const VkMemoryAllocInfo* pAllocInfo, - VkDeviceMemory* pMem); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocateMemory, + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); IMPLEMENT_FUNCTION_SERIALISED(void, vkFreeMemory, - VkDevice device, - VkDeviceMemory mem); + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkMapMemory, - VkDevice device, - VkDeviceMemory mem, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); IMPLEMENT_FUNCTION_SERIALISED(void, vkUnmapMemory, - VkDevice device, - VkDeviceMemory mem); + VkDevice device, + VkDeviceMemory memory); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFlushMappedMemoryRanges, - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkInvalidateMappedMemoryRanges, - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetDeviceMemoryCommitment, - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes); + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetBufferMemoryRequirements, - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements); + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetImageMemoryRequirements, - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements); + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetImageSparseMemoryRequirements, - VkDevice device, - VkImage image, - uint32_t* pNumRequirements, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); // Memory management API functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBindBufferMemory, VkDevice device, VkBuffer buffer, - VkDeviceMemory mem, - VkDeviceSize memOffset); + VkDeviceMemory memory, + VkDeviceSize memoryOffset); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBindImageMemory, VkDevice device, VkImage image, - VkDeviceMemory mem, - VkDeviceSize memOffset); + VkDeviceMemory memory, + VkDeviceSize memoryOffset); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueBindSparseBufferMemory, + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueBindSparse, VkQueue queue, - VkBuffer buffer, - uint32_t numBindings, - const VkSparseMemoryBindInfo* pBindInfo); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueBindSparseImageOpaqueMemory, - VkQueue queue, - VkImage image, - uint32_t numBindings, - const VkSparseMemoryBindInfo* pBindInfo); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueBindSparseImageMemory, - VkQueue queue, - VkImage image, - uint32_t numBindings, - const VkSparseImageMemoryBindInfo* pBindInfo); + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); // Buffer functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateBuffer, - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - VkBuffer* pBuffer); + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyBuffer, - VkDevice device, - VkBuffer buffer); + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); // Buffer view functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateBufferView, - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - VkBufferView* pView); + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyBufferView, - VkDevice device, - VkBufferView view); + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); // Image functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateImage, - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - VkImage* pImage); + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyImage, - VkDevice device, - VkImage image); + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetImageSubresourceLayout, - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); // Image view functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateImageView, - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - VkImageView* pView); + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyImageView, - VkDevice device, - VkImageView view); + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); // Shader functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateShaderModule, - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModule* pShaderModule); + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyShaderModule, - VkDevice device, - VkShaderModule shaderModule); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateShader, - VkDevice device, - const VkShaderCreateInfo* pCreateInfo, - VkShader* pShader); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyShader, - VkDevice device, - VkShader shader); + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); // Pipeline functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateGraphicsPipelines, - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateComputePipelines, - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkComputePipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyPipeline, - VkDevice device, - VkPipeline pipeline); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreatePipelineCache, - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - VkPipelineCache* pPipelineCache); + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyPipelineCache, - VkDevice device, - VkPipelineCache pipelineCache); - - IMPLEMENT_FUNCTION_SERIALISED(size_t, vkGetPipelineCacheSize, - VkDevice device, - VkPipelineCache pipelineCache); + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPipelineCacheData, - VkDevice device, - VkPipelineCache pipelineCache, - void* pData); + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkMergePipelineCaches, - VkDevice device, - VkPipelineCache destCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateGraphicsPipelines, + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateComputePipelines, + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyPipeline, + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); // Pipeline layout functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreatePipelineLayout, - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - VkPipelineLayout* pPipelineLayout); + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyPipelineLayout, - VkDevice device, - VkPipelineLayout pipelineLayout); + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); // Sampler functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSampler, - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - VkSampler* pSampler); + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroySampler, - VkDevice device, - VkSampler sampler); + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); // Descriptor set functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDescriptorSetLayout, - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayout* pSetLayout); + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyDescriptorSetLayout, - VkDevice device, - VkDescriptorSetLayout setLayout); + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDescriptorPool, - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - VkDescriptorPool* pDescriptorPool); + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyDescriptorPool, - VkDevice device, - VkDescriptorPool descriptorPool); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocDescriptorSets, - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorSetUsage setUsage, - uint32_t count, - const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets); + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetDescriptorPool, - VkDevice device, - VkDescriptorPool descriptorPool); + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); - IMPLEMENT_FUNCTION_SERIALISED(void, vkUpdateDescriptorSets, - VkDevice device, - uint32_t writeCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t copyCount, - const VkCopyDescriptorSet* pDescriptorCopies); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocateDescriptorSets, + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFreeDescriptorSets, - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t count, - const VkDescriptorSet* pDescriptorSets); + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkUpdateDescriptorSets, + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); // Command pool functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetRenderAreaGranularity, - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateCommandPool, - VkDevice device, - const VkCmdPoolCreateInfo* pCreateInfo, - VkCommandPool* pCmdPool); + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyCommandPool, - VkDevice device, - VkCommandPool VkCommandPool); + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetCommandPool, - VkDevice device, - VkCommandPool VkCommandPool, - VkCmdPoolResetFlags flags); + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); // Command buffer functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateCommandBuffer, - VkDevice device, - const VkCmdBufferCreateInfo* pCreateInfo, - VkCommandBuffer* pCmdBuffer); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocateCommandBuffers, + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); - IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyCommandBuffer, - VkDevice device, - VkCommandBuffer cmdBuffer); + IMPLEMENT_FUNCTION_SERIALISED(void, vkFreeCommandBuffers, + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBeginCommandBuffer, - VkCommandBuffer cmdBuffer, - const VkCmdBufferBeginInfo* pBeginInfo); + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkEndCommandBuffer, - VkCommandBuffer cmdBuffer); + VkCommandBuffer commandBuffer); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetCommandBuffer, - VkCommandBuffer cmdBuffer, - VkCmdBufferResetFlags flags); + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); // Command buffer building functions IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindPipeline, - VkCommandBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetViewport, - VkCommandBuffer cmdBuffer, - uint32_t viewportCount, - const VkViewport* pViewports); + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetScissor, - VkCommandBuffer cmdBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors); + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetLineWidth, - VkCommandBuffer cmdBuffer, - float lineWidth); + VkCommandBuffer commandBuffer, + float lineWidth); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetDepthBias, - VkCommandBuffer cmdBuffer, - float depthBias, - float depthBiasClamp, - float slopeScaledDepthBias); + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetBlendConstants, - VkCommandBuffer cmdBuffer, - const float blendConst[4]); + VkCommandBuffer commandBuffer, + const float blendConstants[4]); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetDepthBounds, - VkCommandBuffer cmdBuffer, - float minDepthBounds, - float maxDepthBounds); + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetStencilCompareMask, - VkCommandBuffer cmdBuffer, - VkStencilFaceFlags faceMask, - uint32_t stencilCompareMask); + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetStencilWriteMask, - VkCommandBuffer cmdBuffer, - VkStencilFaceFlags faceMask, - uint32_t stencilWriteMask); + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetStencilReference, - VkCommandBuffer cmdBuffer, - VkStencilFaceFlags faceMask, - uint32_t stencilReference); + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets, - VkCommandBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer, - VkCommandBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindVertexBuffers, - VkCommandBuffer cmdBuffer, - uint32_t startBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); + VkCommandBuffer commandBuffer, + uint32_t startBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDraw, - VkCommandBuffer cmdBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance); + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndexed, - VkCommandBuffer cmdBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance); + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndirect, - VkCommandBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndexedIndirect, - VkCommandBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDispatch, - VkCommandBuffer cmdBuffer, - uint32_t x, - uint32_t y, - uint32_t z); + VkCommandBuffer commandBuffer, + uint32_t x, + uint32_t y, + uint32_t z); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDispatchIndirect, - VkCommandBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset); + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBuffer, - VkCommandBuffer cmdBuffer, - VkBuffer srcBuffer, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImage, - VkCommandBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBlitImage, - VkCommandBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkTexFilter filter); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResolveImage, - VkCommandBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBufferToImage, - VkCommandBuffer cmdBuffer, - VkBuffer srcBuffer, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImageToBuffer, - VkCommandBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdUpdateBuffer, - VkCommandBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize dataSize, - const uint32_t* pData); + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const uint32_t* pData); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdFillBuffer, - VkCommandBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize fillSize, - uint32_t data); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushConstants, - VkCommandBuffer cmdBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t start, - uint32_t length, - const void* values); + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize fillSize, + uint32_t data); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearColorImage, - VkCommandBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearDepthStencilImage, - VkCommandBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearColorAttachment, - VkCommandBuffer cmdBuffer, - uint32_t colorAttachment, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rectCount, - const VkRect3D* pRects); + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearDepthStencilAttachment, - VkCommandBuffer cmdBuffer, - VkImageAspectFlags imageAspectMask, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rectCount, - const VkRect3D* pRects); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearAttachments, + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPipelineBarrier, - VkCommandBuffer cmdBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags destStageMask, - VkBool32 byRegion, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdWriteTimestamp, - VkCommandBuffer cmdBuffer, - VkTimestampType timestampType, - VkBuffer destBuffer, - VkDeviceSize destOffset); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyQueryPoolResults, - VkCommandBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize destStride, - VkQueryResultFlags flags); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginQuery, - VkCommandBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot, - VkQueryControlFlags flags); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndQuery, - VkCommandBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResetQueryPool, - VkCommandBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResolveImage, + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetEvent, - VkCommandBuffer cmdBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResetEvent, - VkCommandBuffer cmdBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdWaitEvents, - VkCommandBuffer cmdBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags destStageMask, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags destStageMask, + uint32_t memoryBarrierCount, + const void* const* ppMemoryBarriers); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFramebuffer, - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - VkFramebuffer* pFramebuffer); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyFramebuffer, - VkDevice device, - VkFramebuffer framebuffer); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPipelineBarrier, + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const void* const* ppMemoryBarriers); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateRenderPass, - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - VkRenderPass* pRenderPass); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyRenderPass, - VkDevice device, - VkRenderPass renderPass); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushConstants, + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginRenderPass, - VkCommandBuffer cmdBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkRenderPassContents contents); + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdNextSubpass, - VkCommandBuffer cmdBuffer, - VkRenderPassContents contents); - - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdExecuteCommands, - VkCommandBuffer cmdBuffer, - uint32_t cmdBuffersCount, - const VkCommandBuffer* pCmdBuffers); + VkCommandBuffer commandBuffer, + VkSubpassContents contents); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndRenderPass, - VkCommandBuffer cmdBuffer); + VkCommandBuffer commandBuffer); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdExecuteCommands, + VkCommandBuffer commandBuffer, + uint32_t commandBuffersCount, + const VkCommandBuffer* pCommandBuffers); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdWriteTimestamp, + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t entry); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyQueryPoolResults, + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginQuery, + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t entry, + VkQueryControlFlags flags); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndQuery, + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t entry); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResetQueryPool, + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFramebuffer, + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyFramebuffer, + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateRenderPass, + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkDestroyRenderPass, + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); // Debug functions @@ -1300,60 +1293,63 @@ public: VkDbgMsgCallback msgCallback); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerBegin, - VkCommandBuffer cmdBuffer, - const char* pMarker); + VkCommandBuffer commandBuffer, + const char* pMarker); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerEnd, - VkCommandBuffer cmdBuffer); + VkCommandBuffer commandBuffer); // Windowing extension functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceSurfaceSupportKHR, - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - const VkSurfaceDescriptionKHR* pSurfaceDescription, - VkBool32* pSupported); + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSurfacePropertiesKHR, - VkDevice device, - const VkSurfaceDescriptionKHR* pSurfaceDescription, - VkSurfacePropertiesKHR* pSurfaceProperties); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceSurfaceCapabilitiesKHR, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSurfaceFormatsKHR, - VkDevice device, - const VkSurfaceDescriptionKHR* pSurfaceDescription, - uint32_t* pCount, - VkSurfaceFormatKHR* pSurfaceFormats); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceSurfaceFormatsKHR, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSurfacePresentModesKHR, - VkDevice device, - const VkSurfaceDescriptionKHR* pSurfaceDescription, - uint32_t* pCount, - VkPresentModeKHR* pPresentModes); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceSurfacePresentModesKHR, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSwapchainKHR, - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - VkSwapchainKHR* pSwapchain); + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroySwapchainKHR, - VkDevice device, - VkSwapchainKHR swapchain); + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSwapchainImagesKHR, - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pCount, - VkImage* pSwapchainImages); + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAcquireNextImageKHR, - VkDevice device, - VkSwapchainKHR swapChain, - uint64_t timeout, - VkSemaphore semaphore, - uint32_t* pImageIndex); + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueuePresentKHR, - VkQueue queue, - VkPresentInfoKHR* pPresentInfo); + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); }; diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index 4720976ad..8baad5386 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -46,7 +46,7 @@ HookInit(QueueSubmit); \ HookInit(QueueWaitIdle); \ HookInit(DeviceWaitIdle); \ - HookInit(AllocMemory); \ + HookInit(AllocateMemory); \ HookInit(FreeMemory); \ HookInit(MapMemory); \ HookInit(UnmapMemory); \ @@ -55,9 +55,7 @@ HookInit(GetDeviceMemoryCommitment); \ HookInit(BindBufferMemory); \ HookInit(BindImageMemory); \ - HookInit(QueueBindSparseBufferMemory); \ - HookInit(QueueBindSparseImageOpaqueMemory); \ - HookInit(QueueBindSparseImageMemory); \ + HookInit(QueueBindSparse); \ HookInit(CreateBuffer); \ HookInit(DestroyBuffer); \ HookInit(CreateBufferView); \ @@ -70,15 +68,12 @@ HookInit(GetImageSparseMemoryRequirements); \ HookInit(CreateImageView); \ HookInit(DestroyImageView); \ - HookInit(CreateShader); \ - HookInit(DestroyShader); \ HookInit(CreateShaderModule); \ HookInit(DestroyShaderModule); \ HookInit(CreateGraphicsPipelines); \ HookInit(CreateComputePipelines); \ HookInit(DestroyPipeline); \ HookInit(CreatePipelineCache); \ - HookInit(GetPipelineCacheSize); \ HookInit(GetPipelineCacheData); \ HookInit(MergePipelineCaches); \ HookInit(DestroyPipelineCache); \ @@ -86,8 +81,6 @@ HookInit(DestroyPipelineLayout); \ HookInit(CreateSemaphore); \ HookInit(DestroySemaphore); \ - HookInit(QueueSignalSemaphore); \ - HookInit(QueueWaitSemaphore); \ HookInit(CreateFence); \ HookInit(GetFenceStatus); \ HookInit(ResetFences); \ @@ -108,15 +101,15 @@ HookInit(CreateDescriptorPool); \ HookInit(ResetDescriptorPool); \ HookInit(DestroyDescriptorPool); \ - HookInit(AllocDescriptorSets); \ + HookInit(AllocateDescriptorSets); \ HookInit(UpdateDescriptorSets); \ HookInit(FreeDescriptorSets); \ HookInit(GetRenderAreaGranularity); \ HookInit(CreateCommandPool); \ HookInit(DestroyCommandPool); \ HookInit(ResetCommandPool); \ - HookInit(CreateCommandBuffer); \ - HookInit(DestroyCommandBuffer); \ + HookInit(AllocateCommandBuffers); \ + HookInit(FreeCommandBuffers); \ HookInit(BeginCommandBuffer); \ HookInit(EndCommandBuffer); \ HookInit(ResetCommandBuffer); \ @@ -150,8 +143,7 @@ HookInit(CmdPushConstants); \ HookInit(CmdClearColorImage); \ HookInit(CmdClearDepthStencilImage); \ - HookInit(CmdClearColorAttachment); \ - HookInit(CmdClearDepthStencilAttachment); \ + HookInit(CmdClearAttachments); \ HookInit(CmdPipelineBarrier); \ HookInit(CmdWriteTimestamp); \ HookInit(CmdCopyQueryPoolResults); \ @@ -169,9 +161,9 @@ HookInit(CmdNextSubpass); \ HookInit(CmdExecuteCommands); \ HookInit(CmdEndRenderPass); \ - HookInit(GetSurfacePropertiesKHR); \ - HookInit(GetSurfaceFormatsKHR); \ - HookInit(GetSurfacePresentModesKHR); \ + HookInit(GetPhysicalDeviceSurfaceCapabilitiesKHR); \ + HookInit(GetPhysicalDeviceSurfaceFormatsKHR); \ + HookInit(GetPhysicalDeviceSurfacePresentModesKHR); \ HookInit(CreateSwapchainKHR); \ HookInit(DestroySwapchainKHR); \ HookInit(GetSwapchainImagesKHR); \ @@ -187,14 +179,14 @@ HookDefine2(VkResult, vkGetPhysicalDeviceProperties, VkPhysicalDevice, physicalDevice, VkPhysicalDeviceProperties*, pProperties); \ HookDefine3(VkResult, vkGetPhysicalDeviceQueueFamilyProperties, VkPhysicalDevice, physicalDevice, uint32_t*, pCount, VkQueueFamilyProperties*, pQueueFamilyProperties); \ HookDefine2(VkResult, vkGetPhysicalDeviceMemoryProperties, VkPhysicalDevice, physicalDevice, VkPhysicalDeviceMemoryProperties*, pMemoryProperties); \ - HookDefine3(VkResult, vkCreateDevice, VkPhysicalDevice, physicalDevice, const VkDeviceCreateInfo*, pCreateInfo, VkDevice*, pDevice); \ - HookDefine1(void, vkDestroyDevice, VkDevice, device); \ + HookDefine4(VkResult, vkCreateDevice, VkPhysicalDevice, physicalDevice, const VkDeviceCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkDevice*, pDevice); \ + HookDefine2(void, vkDestroyDevice, VkDevice, device, const VkAllocationCallbacks*, pAllocator); \ HookDefine4(VkResult, vkGetDeviceQueue, VkDevice, device, uint32_t, queueFamilyIndex, uint32_t, queueIndex, VkQueue*, pQueue); \ - HookDefine4(VkResult, vkQueueSubmit, VkQueue, queue, uint32_t, cmdBufferCount, const VkCommandBuffer*, pCmdBuffers, VkFence, fence); \ + HookDefine4(VkResult, vkQueueSubmit, VkQueue, queue, uint32_t, submitCount, const VkSubmitInfo*, pSubmits, VkFence, fence); \ HookDefine1(VkResult, vkQueueWaitIdle, VkQueue, queue); \ HookDefine1(VkResult, vkDeviceWaitIdle, VkDevice, device); \ - HookDefine3(VkResult, vkAllocMemory, VkDevice, device, const VkMemoryAllocInfo*, pAllocInfo, VkDeviceMemory*, pMem); \ - HookDefine2(void, vkFreeMemory, VkDevice, device, VkDeviceMemory, mem); \ + HookDefine4(VkResult, vkAllocateMemory, VkDevice, device, const VkMemoryAllocateInfo*, pAllocInfo, const VkAllocationCallbacks*, pAllocator, VkDeviceMemory*, pMemory); \ + HookDefine3(void, vkFreeMemory, VkDevice, device, VkDeviceMemory, mem, const VkAllocationCallbacks*, pAllocator); \ HookDefine6(VkResult, vkMapMemory, VkDevice, device, VkDeviceMemory, mem, VkDeviceSize, offset, VkDeviceSize, size, VkMemoryMapFlags, flags, void**, ppData); \ HookDefine2(void, vkUnmapMemory, VkDevice, device, VkDeviceMemory, mem); \ HookDefine3(VkResult, vkFlushMappedMemoryRanges, VkDevice, device, uint32_t, memRangeCount, const VkMappedMemoryRange*, pMemRanges); \ @@ -202,128 +194,120 @@ HookDefine3(VkResult, vkGetDeviceMemoryCommitment, VkDevice, device, VkDeviceMemory, memory, VkDeviceSize*, pCommittedMemoryInBytes); \ HookDefine4(VkResult, vkBindBufferMemory, VkDevice, device, VkBuffer, buffer, VkDeviceMemory, mem, VkDeviceSize, memOffset); \ HookDefine4(VkResult, vkBindImageMemory, VkDevice, device, VkImage, image, VkDeviceMemory, mem, VkDeviceSize, memOffset); \ - HookDefine4(VkResult, vkQueueBindSparseBufferMemory, VkQueue, queue, VkBuffer, buffer, uint32_t, numBindings, const VkSparseMemoryBindInfo*, pBindInfo); \ - HookDefine4(VkResult, vkQueueBindSparseImageOpaqueMemory, VkQueue, queue, VkImage, image, uint32_t, numBindings, const VkSparseMemoryBindInfo*, pBindInfo); \ - HookDefine4(VkResult, vkQueueBindSparseImageMemory, VkQueue, queue, VkImage, image, uint32_t, numBindings, const VkSparseImageMemoryBindInfo*, pBindInfo); \ - HookDefine3(VkResult, vkCreateBuffer, VkDevice, device, const VkBufferCreateInfo*, pCreateInfo, VkBuffer*, pBuffer); \ - HookDefine2(void, vkDestroyBuffer, VkDevice, device, VkBuffer, buffer); \ - HookDefine3(VkResult, vkCreateBufferView, VkDevice, device, const VkBufferViewCreateInfo*, pCreateInfo, VkBufferView*, pView); \ - HookDefine2(void, vkDestroyBufferView, VkDevice, device, VkBufferView, bufferView); \ - HookDefine3(VkResult, vkCreateImage, VkDevice, device, const VkImageCreateInfo*, pCreateInfo, VkImage*, pImage); \ - HookDefine2(void, vkDestroyImage, VkDevice, device, VkImage, image); \ + HookDefine4(VkResult, vkQueueBindSparse, VkQueue, queue, uint32_t, bindInfoCount, const VkBindSparseInfo*, pBindInfo, VkFence, fence); \ + HookDefine4(VkResult, vkCreateBuffer, VkDevice, device, const VkBufferCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkBuffer*, pBuffer); \ + HookDefine3(void, vkDestroyBuffer, VkDevice, device, VkBuffer, buffer, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateBufferView, VkDevice, device, const VkBufferViewCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkBufferView*, pView); \ + HookDefine3(void, vkDestroyBufferView, VkDevice, device, VkBufferView, bufferView, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateImage, VkDevice, device, const VkImageCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkImage*, pImage); \ + HookDefine3(void, vkDestroyImage, VkDevice, device, VkImage, image, const VkAllocationCallbacks*, pAllocator); \ HookDefine4(VkResult, vkGetImageSubresourceLayout, VkDevice, device, VkImage, image, const VkImageSubresource*, pSubresource, VkSubresourceLayout*, pLayout); \ HookDefine3(VkResult, vkGetBufferMemoryRequirements, VkDevice, device, VkBuffer, buffer, VkMemoryRequirements*, pMemoryRequirements); \ HookDefine3(VkResult, vkGetImageMemoryRequirements, VkDevice, device, VkImage, image, VkMemoryRequirements*, pMemoryRequirements); \ HookDefine4(VkResult, vkGetImageSparseMemoryRequirements, VkDevice, device, VkImage, image, uint32_t*, pNumRequirements, VkSparseImageMemoryRequirements*, pSparseMemoryRequirements); \ - HookDefine3(VkResult, vkCreateImageView, VkDevice, device, const VkImageViewCreateInfo*, pCreateInfo, VkImageView*, pView); \ - HookDefine2(void, vkDestroyImageView, VkDevice, device, VkImageView, imageView); \ - HookDefine3(VkResult, vkCreateShader, VkDevice, device, const VkShaderCreateInfo*, pCreateInfo, VkShader*, pShader); \ - HookDefine2(void, vkDestroyShader, VkDevice, device, VkShader, shader); \ - HookDefine3(VkResult, vkCreateShaderModule, VkDevice, device, const VkShaderModuleCreateInfo*, pCreateInfo, VkShaderModule*, pShaderModule); \ - HookDefine2(void, vkDestroyShaderModule, VkDevice, device, VkShaderModule, shaderModule); \ - HookDefine5(VkResult, vkCreateGraphicsPipelines, VkDevice, device, VkPipelineCache, pipelineCache, uint32_t, count, const VkGraphicsPipelineCreateInfo*, pCreateInfos, VkPipeline*, pPipelines); \ - HookDefine5(VkResult, vkCreateComputePipelines, VkDevice, device, VkPipelineCache, pipelineCache, uint32_t, count, const VkComputePipelineCreateInfo*, pCreateInfos, VkPipeline*, pPipelines); \ - HookDefine2(void, vkDestroyPipeline, VkDevice, device, VkPipeline, pipeline); \ - HookDefine3(VkResult, vkCreatePipelineCache, VkDevice, device, const VkPipelineCacheCreateInfo*, pCreateInfo, VkPipelineCache*, pPipelineCache); \ - HookDefine2(void, vkDestroyPipelineCache, VkDevice, device, VkPipelineCache, pipelineCache); \ - HookDefine2(size_t, vkGetPipelineCacheSize, VkDevice, device, VkPipelineCache, pipelineCache); \ - HookDefine3(VkResult, vkGetPipelineCacheData, VkDevice, device, VkPipelineCache, pipelineCache, void*, pData); \ + HookDefine4(VkResult, vkCreateImageView, VkDevice, device, const VkImageViewCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkImageView*, pView); \ + HookDefine3(void, vkDestroyImageView, VkDevice, device, VkImageView, imageView, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateShaderModule, VkDevice, device, const VkShaderModuleCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkShaderModule*, pShaderModule); \ + HookDefine3(void, vkDestroyShaderModule, VkDevice, device, VkShaderModule, shaderModule, const VkAllocationCallbacks*, pAllocator); \ + HookDefine6(VkResult, vkCreateGraphicsPipelines, VkDevice, device, VkPipelineCache, pipelineCache, uint32_t, count, const VkGraphicsPipelineCreateInfo*, pCreateInfos, const VkAllocationCallbacks*, pAllocator, VkPipeline*, pPipelines); \ + HookDefine6(VkResult, vkCreateComputePipelines, VkDevice, device, VkPipelineCache, pipelineCache, uint32_t, count, const VkComputePipelineCreateInfo*, pCreateInfos, const VkAllocationCallbacks*, pAllocator, VkPipeline*, pPipelines); \ + HookDefine3(void, vkDestroyPipeline, VkDevice, device, VkPipeline, pipeline, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreatePipelineCache, VkDevice, device, const VkPipelineCacheCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkPipelineCache*, pPipelineCache); \ + HookDefine3(void, vkDestroyPipelineCache, VkDevice, device, VkPipelineCache, pipelineCache, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkGetPipelineCacheData, VkDevice, device, VkPipelineCache, pipelineCache, size_t*, pDataSize, void*, pData); \ HookDefine4(VkResult, vkMergePipelineCaches, VkDevice, device, VkPipelineCache, pipelineCache, uint32_t, srcCacheCount, const VkPipelineCache*, pSrcCaches); \ - HookDefine3(VkResult, vkCreatePipelineLayout, VkDevice, device, const VkPipelineLayoutCreateInfo*, pCreateInfo, VkPipelineLayout*, pPipelineLayout); \ - HookDefine2(void, vkDestroyPipelineLayout, VkDevice, device, VkPipelineLayout, pipelineLayout); \ - HookDefine3(VkResult, vkCreateSemaphore, VkDevice, device, const VkSemaphoreCreateInfo*, pCreateInfo, VkSemaphore*, pSemaphore); \ - HookDefine2(void, vkDestroySemaphore, VkDevice, device, VkSemaphore, semaphore); \ - HookDefine2(VkResult, vkQueueSignalSemaphore, VkQueue, queue, VkSemaphore, semaphore); \ - HookDefine2(VkResult, vkQueueWaitSemaphore, VkQueue, queue, VkSemaphore, semaphore); \ - HookDefine3(VkResult, vkCreateFence, VkDevice, device, const VkFenceCreateInfo*, pCreateInfo, VkFence*, pFence); \ - HookDefine2(void, vkDestroyFence, VkDevice, device, VkFence, fence); \ - HookDefine3(VkResult, vkCreateEvent, VkDevice, device, const VkEventCreateInfo*, pCreateInfo, VkEvent*, pEvent); \ - HookDefine2(void, vkDestroyEvent, VkDevice, device, VkEvent, event); \ + HookDefine4(VkResult, vkCreatePipelineLayout, VkDevice, device, const VkPipelineLayoutCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkPipelineLayout*, pPipelineLayout); \ + HookDefine3(void, vkDestroyPipelineLayout, VkDevice, device, VkPipelineLayout, pipelineLayout, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateSemaphore, VkDevice, device, const VkSemaphoreCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkSemaphore*, pSemaphore); \ + HookDefine3(void, vkDestroySemaphore, VkDevice, device, VkSemaphore, semaphore, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateFence, VkDevice, device, const VkFenceCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkFence*, pFence); \ + HookDefine3(void, vkDestroyFence, VkDevice, device, VkFence, fence, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateEvent, VkDevice, device, const VkEventCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkEvent*, pEvent); \ + HookDefine3(void, vkDestroyEvent, VkDevice, device, VkEvent, event, const VkAllocationCallbacks*, pAllocator); \ HookDefine2(VkResult, vkGetEventStatus, VkDevice, device, VkEvent, event); \ HookDefine2(VkResult, vkSetEvent, VkDevice, device, VkEvent, event); \ HookDefine2(VkResult, vkResetEvent, VkDevice, device, VkEvent, event); \ - HookDefine3(VkResult, vkCreateQueryPool, VkDevice, device, const VkQueryPoolCreateInfo*, pCreateInfo, VkQueryPool*, pQueryPool); \ - HookDefine2(void, vkDestroyQueryPool, VkDevice, device, VkQueryPool, queryPool); \ - HookDefine7(VkResult, vkGetQueryPoolResults, VkDevice, device, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount, size_t*, pDataSize, void*, pData, VkQueryResultFlags, flags); \ + HookDefine4(VkResult, vkCreateQueryPool, VkDevice, device, const VkQueryPoolCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkQueryPool*, pQueryPool); \ + HookDefine3(void, vkDestroyQueryPool, VkDevice, device, VkQueryPool, queryPool, const VkAllocationCallbacks*, pAllocator); \ + HookDefine8(VkResult, vkGetQueryPoolResults, VkDevice, device, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount, size_t, dataSize, void*, pData, VkDeviceSize, stride, VkQueryResultFlags, flags); \ HookDefine2(VkResult, vkGetFenceStatus, VkDevice, device, VkFence, fence); \ HookDefine3(VkResult, vkResetFences, VkDevice, device, uint32_t, fenceCount, const VkFence*, pFences); \ HookDefine5(VkResult, vkWaitForFences, VkDevice, device, uint32_t, fenceCount, const VkFence*, pFences, VkBool32, waitAll, uint64_t, timeout); \ - HookDefine3(VkResult, vkCreateSampler, VkDevice, device, const VkSamplerCreateInfo*, pCreateInfo, VkSampler*, pSampler); \ - HookDefine2(void, vkDestroySampler, VkDevice, device, VkSampler, sampler); \ - HookDefine3(VkResult, vkCreateDescriptorSetLayout, VkDevice, device, const VkDescriptorSetLayoutCreateInfo*, pCreateInfo, VkDescriptorSetLayout*, pSetLayout); \ - HookDefine2(void, vkDestroyDescriptorSetLayout, VkDevice, device, VkDescriptorSetLayout, descriptorSetLayout); \ - HookDefine3(VkResult, vkCreateDescriptorPool, VkDevice, device, const VkDescriptorPoolCreateInfo*, pCreateInfo, VkDescriptorPool*, pDescriptorPool); \ - HookDefine2(void, vkDestroyDescriptorPool, VkDevice, device, VkDescriptorPool, descriptorPool); \ - HookDefine2(VkResult, vkResetDescriptorPool, VkDevice, device, VkDescriptorPool, descriptorPool); \ - HookDefine6(VkResult, vkAllocDescriptorSets, VkDevice, device, VkDescriptorPool, descriptorPool, VkDescriptorSetUsage, setUsage, uint32_t, count, const VkDescriptorSetLayout*, pSetLayouts, VkDescriptorSet*, pDescriptorSets); \ + HookDefine4(VkResult, vkCreateSampler, VkDevice, device, const VkSamplerCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkSampler*, pSampler); \ + HookDefine3(void, vkDestroySampler, VkDevice, device, VkSampler, sampler, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateDescriptorSetLayout, VkDevice, device, const VkDescriptorSetLayoutCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkDescriptorSetLayout*, pSetLayout); \ + HookDefine3(void, vkDestroyDescriptorSetLayout, VkDevice, device, VkDescriptorSetLayout, descriptorSetLayout, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateDescriptorPool, VkDevice, device, const VkDescriptorPoolCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkDescriptorPool*, pDescriptorPool); \ + HookDefine3(void, vkDestroyDescriptorPool, VkDevice, device, VkDescriptorPool, descriptorPool, const VkAllocationCallbacks*, pAllocator); \ + HookDefine3(VkResult, vkResetDescriptorPool, VkDevice, device, VkDescriptorPool, descriptorPool, VkDescriptorPoolResetFlags, flags); \ + HookDefine3(VkResult, vkAllocateDescriptorSets, VkDevice, device, const VkDescriptorSetAllocateInfo*, pAllocateInfo, VkDescriptorSet*, pDescriptorSets); \ HookDefine5(void, vkUpdateDescriptorSets, VkDevice, device, uint32_t, writeCount, const VkWriteDescriptorSet*, pDescriptorWrites, uint32_t, copyCount, const VkCopyDescriptorSet*, pDescriptorCopies); \ HookDefine4(VkResult, vkFreeDescriptorSets, VkDevice, device, VkDescriptorPool, descriptorPool, uint32_t, count, const VkDescriptorSet*, pDescriptorSets); \ - HookDefine3(VkResult, vkCreateCommandPool, VkDevice, device, const VkCmdPoolCreateInfo*, pCreateInfo, VkCommandPool*, pCmdPool); \ - HookDefine2(void, vkDestroyCommandPool, VkDevice, device, VkCommandPool, cmdPool); \ - HookDefine3(VkResult, vkResetCommandPool, VkDevice, device, VkCommandPool, cmdPool, VkCmdPoolResetFlags, flags); \ - HookDefine3(VkResult, vkCreateCommandBuffer, VkDevice, device, const VkCmdBufferCreateInfo*, pCreateInfo, VkCommandBuffer*, pCmdBuffer); \ - HookDefine2(void, vkDestroyCommandBuffer, VkDevice, device, VkCommandBuffer, cmdBuffer); \ - HookDefine2(VkResult, vkBeginCommandBuffer, VkCommandBuffer, cmdBuffer, const VkCmdBufferBeginInfo*, pBeginInfo); \ - HookDefine1(VkResult, vkEndCommandBuffer, VkCommandBuffer, cmdBuffer); \ - HookDefine2(VkResult, vkResetCommandBuffer, VkCommandBuffer, cmdBuffer, VkCmdBufferResetFlags, flags); \ - HookDefine3(void, vkCmdBindPipeline, VkCommandBuffer, cmdBuffer, VkPipelineBindPoint, pipelineBindPoint, VkPipeline, pipeline); \ - HookDefine3(void, vkCmdSetViewport, VkCommandBuffer, cmdBuffer, uint32_t, viewportCount, const VkViewport*, pViewports); \ - HookDefine3(void, vkCmdSetScissor, VkCommandBuffer, cmdBuffer, uint32_t, scissorCount, const VkRect2D*, pScissors); \ - HookDefine2(void, vkCmdSetLineWidth, VkCommandBuffer, cmdBuffer, float, lineWidth); \ - HookDefine4(void, vkCmdSetDepthBias, VkCommandBuffer, cmdBuffer, float, depthBias, float, depthBiasClamp, float, slopeScaledDepthBias); \ - HookDefine2(void, vkCmdSetBlendConstants, VkCommandBuffer, cmdBuffer, const float*, blendConst); \ - HookDefine3(void, vkCmdSetDepthBounds, VkCommandBuffer, cmdBuffer, float, minDepthBounds, float, maxDepthBounds); \ - HookDefine3(void, vkCmdSetStencilCompareMask, VkCommandBuffer, cmdBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilCompareMask); \ - HookDefine3(void, vkCmdSetStencilWriteMask, VkCommandBuffer, cmdBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilWriteMask); \ - HookDefine3(void, vkCmdSetStencilReference, VkCommandBuffer, cmdBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilReference); \ - HookDefine8(void, vkCmdBindDescriptorSets, VkCommandBuffer, cmdBuffer, VkPipelineBindPoint, pipelineBindPoint, VkPipelineLayout, layout, uint32_t, firstSet, uint32_t, setCount, const VkDescriptorSet*, pDescriptorSets, uint32_t, dynamicOffsetCount, const uint32_t*, pDynamicOffsets); \ - HookDefine4(void, vkCmdBindIndexBuffer, VkCommandBuffer, cmdBuffer, VkBuffer, buffer, VkDeviceSize, offset, VkIndexType, indexType); \ - HookDefine5(void, vkCmdBindVertexBuffers, VkCommandBuffer, cmdBuffer, uint32_t, startBinding, uint32_t, bindingCount, const VkBuffer*, pBuffers, const VkDeviceSize*, pOffsets); \ - HookDefine5(void, vkCmdDraw, VkCommandBuffer, cmdBuffer, uint32_t, vertexCount, uint32_t, instanceCount, uint32_t, firstVertex, uint32_t, firstInstance); \ - HookDefine6(void, vkCmdDrawIndexed, VkCommandBuffer, cmdBuffer, uint32_t, indexCount, uint32_t, instanceCount, uint32_t, firstIndex, int32_t, vertexOffset, uint32_t, firstInstance); \ - HookDefine5(void, vkCmdDrawIndirect, VkCommandBuffer, cmdBuffer, VkBuffer, buffer, VkDeviceSize, offset, uint32_t, count, uint32_t, stride); \ - HookDefine5(void, vkCmdDrawIndexedIndirect, VkCommandBuffer, cmdBuffer, VkBuffer, buffer, VkDeviceSize, offset, uint32_t, count, uint32_t, stride); \ - HookDefine4(void, vkCmdDispatch, VkCommandBuffer, cmdBuffer, uint32_t, x, uint32_t, y, uint32_t, z); \ - HookDefine3(void, vkCmdDispatchIndirect, VkCommandBuffer, cmdBuffer, VkBuffer, buffer, VkDeviceSize, offset); \ - HookDefine6(void, vkCmdCopyBufferToImage, VkCommandBuffer, cmdBuffer, VkBuffer, srcBuffer, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkBufferImageCopy*, pRegions); \ - HookDefine6(void, vkCmdCopyImageToBuffer, VkCommandBuffer, cmdBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkBuffer, destBuffer, uint32_t, regionCount, const VkBufferImageCopy*, pRegions); \ - HookDefine5(void, vkCmdCopyBuffer, VkCommandBuffer, cmdBuffer, VkBuffer, srcBuffer, VkBuffer, destBuffer, uint32_t, regionCount, const VkBufferCopy*, pRegions); \ - HookDefine7(void, vkCmdCopyImage, VkCommandBuffer, cmdBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkImageCopy*, pRegions); \ - HookDefine8(void, vkCmdBlitImage, VkCommandBuffer, cmdBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkImageBlit*, pRegions, VkTexFilter, filter); \ - HookDefine7(void, vkCmdResolveImage, VkCommandBuffer, cmdBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkImageResolve*, pRegions); \ - HookDefine5(void, vkCmdUpdateBuffer, VkCommandBuffer, cmdBuffer, VkBuffer, destBuffer, VkDeviceSize, destOffset, VkDeviceSize, dataSize, const uint32_t*, pData); \ - HookDefine5(void, vkCmdFillBuffer, VkCommandBuffer, cmdBuffer, VkBuffer, destBuffer, VkDeviceSize, destOffset, VkDeviceSize, fillSize, uint32_t, data); \ - HookDefine6(void, vkCmdPushConstants, VkCommandBuffer, cmdBuffer, VkPipelineLayout, layout, VkShaderStageFlags, stageFlags, uint32_t, start, uint32_t, length, const void*, values); \ - HookDefine6(void, vkCmdClearColorImage, VkCommandBuffer, cmdBuffer, VkImage, image, VkImageLayout, imageLayout, const VkClearColorValue*, pColor, uint32_t, rangeCount, const VkImageSubresourceRange*, pRanges); \ - HookDefine6(void, vkCmdClearDepthStencilImage, VkCommandBuffer, cmdBuffer, VkImage, image, VkImageLayout, imageLayout, const VkClearDepthStencilValue*, pDepthStencil, uint32_t, rangeCount, const VkImageSubresourceRange*, pRanges); \ - HookDefine6(void, vkCmdClearColorAttachment, VkCommandBuffer, cmdBuffer, uint32_t, colorAttachment, VkImageLayout, imageLayout, const VkClearColorValue*, pColor, uint32_t, rectCount, const VkRect3D*, pRects); \ - HookDefine6(void, vkCmdClearDepthStencilAttachment, VkCommandBuffer, cmdBuffer, VkImageAspectFlags, aspectMask, VkImageLayout, imageLayout, const VkClearDepthStencilValue*, pDepthStencil, uint32_t, rectCount, const VkRect3D*, pRects); \ - HookDefine6(void, vkCmdPipelineBarrier, VkCommandBuffer, cmdBuffer, VkPipelineStageFlags, srcStageMask, VkPipelineStageFlags, destStageMask, VkBool32, byRegion, uint32_t, memBarrierCount, const void* const*, ppMemBarriers); \ - HookDefine4(void, vkCmdWriteTimestamp, VkCommandBuffer, cmdBuffer, VkTimestampType, timestampType, VkBuffer, destBuffer, VkDeviceSize, destOffset); \ - HookDefine8(void, vkCmdCopyQueryPoolResults, VkCommandBuffer, cmdBuffer, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount, VkBuffer, destBuffer, VkDeviceSize, destOffset, VkDeviceSize, destStride, VkQueryResultFlags, flags); \ - HookDefine4(void, vkCmdBeginQuery, VkCommandBuffer, cmdBuffer, VkQueryPool, queryPool, uint32_t, slot, VkQueryControlFlags, flags); \ - HookDefine3(void, vkCmdEndQuery, VkCommandBuffer, cmdBuffer, VkQueryPool, queryPool, uint32_t, slot); \ - HookDefine4(void, vkCmdResetQueryPool, VkCommandBuffer, cmdBuffer, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount); \ - HookDefine3(void, vkCmdSetEvent, VkCommandBuffer, cmdBuffer, VkEvent, event, VkPipelineStageFlags, stageMask); \ - HookDefine3(void, vkCmdResetEvent, VkCommandBuffer, cmdBuffer, VkEvent, event, VkPipelineStageFlags, stageMask); \ - HookDefine7(void, vkCmdWaitEvents, VkCommandBuffer, cmdBuffer, uint32_t, eventCount, const VkEvent*, pEvents, VkPipelineStageFlags, srcStageMask, VkPipelineStageFlags, destStageMask, uint32_t, memBarrierCount, const void* const*, ppMemBarriers); \ - HookDefine3(VkResult, vkCreateFramebuffer, VkDevice, device, const VkFramebufferCreateInfo*, pCreateInfo, VkFramebuffer*, pFramebuffer); \ - HookDefine2(void, vkDestroyFramebuffer, VkDevice, device, VkFramebuffer, framebuffer); \ - HookDefine3(VkResult, vkCreateRenderPass, VkDevice, device, const VkRenderPassCreateInfo*, pCreateInfo, VkRenderPass*, pRenderPass); \ - HookDefine2(void, vkDestroyRenderPass, VkDevice, device, VkRenderPass, renderPass); \ + HookDefine4(VkResult, vkCreateCommandPool, VkDevice, device, const VkCommandPoolCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkCommandPool*, pCommandPool); \ + HookDefine3(void, vkDestroyCommandPool, VkDevice, device, VkCommandPool, commandPool, const VkAllocationCallbacks*, pAllocator); \ + HookDefine3(VkResult, vkResetCommandPool, VkDevice, device, VkCommandPool, commandPool, VkCommandPoolResetFlags, flags); \ + HookDefine3(VkResult, vkAllocateCommandBuffers, VkDevice, device, const VkCommandBufferAllocateInfo*, pCreateInfo, VkCommandBuffer*, pCommandBuffers); \ + HookDefine4(void, vkFreeCommandBuffers, VkDevice, device, VkCommandPool, commandPool, uint32_t, commandBufferCount, const VkCommandBuffer*, pCommandBuffers); \ + HookDefine2(VkResult, vkBeginCommandBuffer, VkCommandBuffer, commandBuffer, const VkCommandBufferBeginInfo*, pBeginInfo); \ + HookDefine1(VkResult, vkEndCommandBuffer, VkCommandBuffer, commandBuffer); \ + HookDefine2(VkResult, vkResetCommandBuffer, VkCommandBuffer, commandBuffer, VkCommandBufferResetFlags, flags); \ + HookDefine3(void, vkCmdBindPipeline, VkCommandBuffer, commandBuffer, VkPipelineBindPoint, pipelineBindPoint, VkPipeline, pipeline); \ + HookDefine3(void, vkCmdSetViewport, VkCommandBuffer, commandBuffer, uint32_t, viewportCount, const VkViewport*, pViewports); \ + HookDefine3(void, vkCmdSetScissor, VkCommandBuffer, commandBuffer, uint32_t, scissorCount, const VkRect2D*, pScissors); \ + HookDefine2(void, vkCmdSetLineWidth, VkCommandBuffer, commandBuffer, float, lineWidth); \ + HookDefine4(void, vkCmdSetDepthBias, VkCommandBuffer, commandBuffer, float, depthBias, float, depthBiasClamp, float, slopeScaledDepthBias); \ + HookDefine2(void, vkCmdSetBlendConstants, VkCommandBuffer, commandBuffer, const float*, blendConst); \ + HookDefine3(void, vkCmdSetDepthBounds, VkCommandBuffer, commandBuffer, float, minDepthBounds, float, maxDepthBounds); \ + HookDefine3(void, vkCmdSetStencilCompareMask, VkCommandBuffer, commandBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilCompareMask); \ + HookDefine3(void, vkCmdSetStencilWriteMask, VkCommandBuffer, commandBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilWriteMask); \ + HookDefine3(void, vkCmdSetStencilReference, VkCommandBuffer, commandBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilReference); \ + HookDefine8(void, vkCmdBindDescriptorSets, VkCommandBuffer, commandBuffer, VkPipelineBindPoint, pipelineBindPoint, VkPipelineLayout, layout, uint32_t, firstSet, uint32_t, setCount, const VkDescriptorSet*, pDescriptorSets, uint32_t, dynamicOffsetCount, const uint32_t*, pDynamicOffsets); \ + HookDefine4(void, vkCmdBindIndexBuffer, VkCommandBuffer, commandBuffer, VkBuffer, buffer, VkDeviceSize, offset, VkIndexType, indexType); \ + HookDefine5(void, vkCmdBindVertexBuffers, VkCommandBuffer, commandBuffer, uint32_t, startBinding, uint32_t, bindingCount, const VkBuffer*, pBuffers, const VkDeviceSize*, pOffsets); \ + HookDefine5(void, vkCmdDraw, VkCommandBuffer, commandBuffer, uint32_t, vertexCount, uint32_t, instanceCount, uint32_t, firstVertex, uint32_t, firstInstance); \ + HookDefine6(void, vkCmdDrawIndexed, VkCommandBuffer, commandBuffer, uint32_t, indexCount, uint32_t, instanceCount, uint32_t, firstIndex, int32_t, vertexOffset, uint32_t, firstInstance); \ + HookDefine5(void, vkCmdDrawIndirect, VkCommandBuffer, commandBuffer, VkBuffer, buffer, VkDeviceSize, offset, uint32_t, count, uint32_t, stride); \ + HookDefine5(void, vkCmdDrawIndexedIndirect, VkCommandBuffer, commandBuffer, VkBuffer, buffer, VkDeviceSize, offset, uint32_t, count, uint32_t, stride); \ + HookDefine4(void, vkCmdDispatch, VkCommandBuffer, commandBuffer, uint32_t, x, uint32_t, y, uint32_t, z); \ + HookDefine3(void, vkCmdDispatchIndirect, VkCommandBuffer, commandBuffer, VkBuffer, buffer, VkDeviceSize, offset); \ + HookDefine6(void, vkCmdCopyBufferToImage, VkCommandBuffer, commandBuffer, VkBuffer, srcBuffer, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkBufferImageCopy*, pRegions); \ + HookDefine6(void, vkCmdCopyImageToBuffer, VkCommandBuffer, commandBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkBuffer, destBuffer, uint32_t, regionCount, const VkBufferImageCopy*, pRegions); \ + HookDefine5(void, vkCmdCopyBuffer, VkCommandBuffer, commandBuffer, VkBuffer, srcBuffer, VkBuffer, destBuffer, uint32_t, regionCount, const VkBufferCopy*, pRegions); \ + HookDefine7(void, vkCmdCopyImage, VkCommandBuffer, commandBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkImageCopy*, pRegions); \ + HookDefine8(void, vkCmdBlitImage, VkCommandBuffer, commandBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkImageBlit*, pRegions, VkFilter, filter); \ + HookDefine7(void, vkCmdResolveImage, VkCommandBuffer, commandBuffer, VkImage, srcImage, VkImageLayout, srcImageLayout, VkImage, destImage, VkImageLayout, destImageLayout, uint32_t, regionCount, const VkImageResolve*, pRegions); \ + HookDefine5(void, vkCmdUpdateBuffer, VkCommandBuffer, commandBuffer, VkBuffer, destBuffer, VkDeviceSize, destOffset, VkDeviceSize, dataSize, const uint32_t*, pData); \ + HookDefine5(void, vkCmdFillBuffer, VkCommandBuffer, commandBuffer, VkBuffer, destBuffer, VkDeviceSize, destOffset, VkDeviceSize, fillSize, uint32_t, data); \ + HookDefine6(void, vkCmdPushConstants, VkCommandBuffer, commandBuffer, VkPipelineLayout, layout, VkShaderStageFlags, stageFlags, uint32_t, start, uint32_t, length, const void*, values); \ + HookDefine6(void, vkCmdClearColorImage, VkCommandBuffer, commandBuffer, VkImage, image, VkImageLayout, imageLayout, const VkClearColorValue*, pColor, uint32_t, rangeCount, const VkImageSubresourceRange*, pRanges); \ + HookDefine6(void, vkCmdClearDepthStencilImage, VkCommandBuffer, commandBuffer, VkImage, image, VkImageLayout, imageLayout, const VkClearDepthStencilValue*, pDepthStencil, uint32_t, rangeCount, const VkImageSubresourceRange*, pRanges); \ + HookDefine5(void, vkCmdClearAttachments, VkCommandBuffer, commandBuffer, uint32_t, attachmentCount, const VkClearAttachment*, pAttachments, uint32_t, rectCount, const VkClearRect*, pRects); \ + HookDefine6(void, vkCmdPipelineBarrier, VkCommandBuffer, commandBuffer, VkPipelineStageFlags, srcStageMask, VkPipelineStageFlags, destStageMask, VkBool32, byRegion, uint32_t, memBarrierCount, const void* const*, ppMemBarriers); \ + HookDefine4(void, vkCmdWriteTimestamp, VkCommandBuffer, commandBuffer, VkPipelineStageFlagBits, pipelineStage, VkQueryPool, queryPool, uint32_t, entry); \ + HookDefine8(void, vkCmdCopyQueryPoolResults, VkCommandBuffer, commandBuffer, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount, VkBuffer, dstBuffer, VkDeviceSize, dstOffset, VkDeviceSize, stride, VkQueryResultFlags, flags); \ + HookDefine4(void, vkCmdBeginQuery, VkCommandBuffer, commandBuffer, VkQueryPool, queryPool, uint32_t, slot, VkQueryControlFlags, flags); \ + HookDefine3(void, vkCmdEndQuery, VkCommandBuffer, commandBuffer, VkQueryPool, queryPool, uint32_t, slot); \ + HookDefine4(void, vkCmdResetQueryPool, VkCommandBuffer, commandBuffer, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount); \ + HookDefine3(void, vkCmdSetEvent, VkCommandBuffer, commandBuffer, VkEvent, event, VkPipelineStageFlags, stageMask); \ + HookDefine3(void, vkCmdResetEvent, VkCommandBuffer, commandBuffer, VkEvent, event, VkPipelineStageFlags, stageMask); \ + HookDefine7(void, vkCmdWaitEvents, VkCommandBuffer, commandBuffer, uint32_t, eventCount, const VkEvent*, pEvents, VkPipelineStageFlags, srcStageMask, VkPipelineStageFlags, destStageMask, uint32_t, memBarrierCount, const void* const*, ppMemBarriers); \ + HookDefine4(VkResult, vkCreateFramebuffer, VkDevice, device, const VkFramebufferCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkFramebuffer*, pFramebuffer); \ + HookDefine3(void, vkDestroyFramebuffer, VkDevice, device, VkFramebuffer, framebuffer, const VkAllocationCallbacks*, pAllocator); \ + HookDefine4(VkResult, vkCreateRenderPass, VkDevice, device, const VkRenderPassCreateInfo*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkRenderPass*, pRenderPass); \ + HookDefine3(void, vkDestroyRenderPass, VkDevice, device, VkRenderPass, renderPass, const VkAllocationCallbacks*, pAllocator); \ HookDefine3(VkResult, vkGetRenderAreaGranularity, VkDevice, device, VkRenderPass, renderPass, VkExtent2D*, pGranularity); \ - HookDefine3(void, vkCmdBeginRenderPass, VkCommandBuffer, cmdBuffer, const VkRenderPassBeginInfo*, pRenderPassBegin, VkRenderPassContents, contents); \ - HookDefine2(void, vkCmdNextSubpass, VkCommandBuffer, cmdBuffer, VkRenderPassContents, contents); \ - HookDefine3(void, vkCmdExecuteCommands, VkCommandBuffer, cmdBuffer, uint32_t, cmdBuffersCount, const VkCommandBuffer*, pCmdBuffers); \ - HookDefine1(void, vkCmdEndRenderPass, VkCommandBuffer, cmdBuffer); \ + HookDefine3(void, vkCmdBeginRenderPass, VkCommandBuffer, commandBuffer, const VkRenderPassBeginInfo*, pRenderPassBegin, VkSubpassContents, contents); \ + HookDefine2(void, vkCmdNextSubpass, VkCommandBuffer, commandBuffer, VkSubpassContents, contents); \ + HookDefine3(void, vkCmdExecuteCommands, VkCommandBuffer, commandBuffer, uint32_t, commandBuffersCount, const VkCommandBuffer*, pCommandBuffers); \ + HookDefine1(void, vkCmdEndRenderPass, VkCommandBuffer, commandBuffer); \ HookDefine5(VkResult, vkDbgCreateMsgCallback, VkInstance, instance, VkFlags, msgFlags, const PFN_vkDbgMsgCallback, pfnMsgCallback, void*, pUserData, VkDbgMsgCallback*, pMsgCallback); \ HookDefine2(VkResult, vkDbgDestroyMsgCallback, VkInstance, instance, VkDbgMsgCallback, msgCallback); \ - HookDefine4(VkResult, vkGetPhysicalDeviceSurfaceSupportKHR, VkPhysicalDevice, physicalDevice, uint32_t, queueFamilyIndex, const VkSurfaceDescriptionKHR*, pSurfaceDescription, VkBool32*, pSupported); \ - HookDefine3(VkResult, vkGetSurfacePropertiesKHR, VkDevice, device, const VkSurfaceDescriptionKHR*, pSurfaceDescription, VkSurfacePropertiesKHR*, pSurfaceProperties); \ - HookDefine4(VkResult, vkGetSurfaceFormatsKHR, VkDevice, device, const VkSurfaceDescriptionKHR*, pSurfaceDescription, uint32_t*, pCount, VkSurfaceFormatKHR*, pSurfaceFormats); \ - HookDefine4(VkResult, vkGetSurfacePresentModesKHR, VkDevice, device, const VkSurfaceDescriptionKHR*, pSurfaceDescription, uint32_t*, pCount, VkPresentModeKHR*, pPresentModes); \ - HookDefine3(VkResult, vkCreateSwapchainKHR, VkDevice, device, const VkSwapchainCreateInfoKHR*, pCreateInfo, VkSwapchainKHR*, pSwapchain); \ - HookDefine2(VkResult, vkDestroySwapchainKHR, VkDevice, device, VkSwapchainKHR, swapchain); \ + HookDefine4(VkResult, vkGetPhysicalDeviceSurfaceSupportKHR, VkPhysicalDevice, physicalDevice, uint32_t, queueFamilyIndex, VkSurfaceKHR, surface, VkBool32*, pSupported); \ + HookDefine3(VkResult, vkGetPhysicalDeviceSurfaceCapabilitiesKHR, VkPhysicalDevice, physicalDevice, VkSurfaceKHR, surface, VkSurfaceCapabilitiesKHR*, pSurfaceProperties); \ + HookDefine4(VkResult, vkGetPhysicalDeviceSurfaceFormatsKHR, VkPhysicalDevice, physicalDevice, VkSurfaceKHR, surface, uint32_t*, pSurfaceFormatCount, VkSurfaceFormatKHR*, pSurfaceFormats); \ + HookDefine4(VkResult, vkGetPhysicalDeviceSurfacePresentModesKHR, VkPhysicalDevice, physicalDevice, VkSurfaceKHR, surface, uint32_t*, pPresentModeCount, VkPresentModeKHR*, pPresentModes); \ + HookDefine4(VkResult, vkCreateSwapchainKHR, VkDevice, device, const VkSwapchainCreateInfoKHR*, pCreateInfo, const VkAllocationCallbacks*, pAllocator, VkSwapchainKHR*, pSwapchain); \ + HookDefine3(VkResult, vkDestroySwapchainKHR, VkDevice, device, VkSwapchainKHR, swapchain, const VkAllocationCallbacks*, pAllocator); \ HookDefine4(VkResult, vkGetSwapchainImagesKHR, VkDevice, device, VkSwapchainKHR, swapchain, uint32_t*, pCount, VkImage*, pSwapchainImages); \ - HookDefine5(VkResult, vkAcquireNextImageKHR, VkDevice, device, VkSwapchainKHR, swapchain, uint64_t, timeout, VkSemaphore, semaphore, uint32_t*, pImageIndex); \ + HookDefine6(VkResult, vkAcquireNextImageKHR, VkDevice, device, VkSwapchainKHR, swapchain, uint64_t, timeout, VkSemaphore, semaphore, VkFence, fence, uint32_t*, pImageIndex); \ HookDefine2(VkResult, vkQueuePresentKHR, VkQueue, queue, VkPresentInfoKHR*, pPresentInfo); diff --git a/renderdoc/driver/vulkan/vk_tracelayer.cpp b/renderdoc/driver/vulkan/vk_tracelayer.cpp index 11abb3f3a..566da7649 100644 --- a/renderdoc/driver/vulkan/vk_tracelayer.cpp +++ b/renderdoc/driver/vulkan/vk_tracelayer.cpp @@ -53,28 +53,28 @@ void InitInstanceTable(const VkBaseLayerObject *obj); // as the first parameter #define HookDefine1(ret, function, t1, p1) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1) \ { return CoreDisp(p1)->function(p1); } #define HookDefine2(ret, function, t1, p1, t2, p2) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1, t2 p2) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1, t2 p2) \ { return CoreDisp(p1)->function(p1, p2); } #define HookDefine3(ret, function, t1, p1, t2, p2, t3, p3) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3) \ { return CoreDisp(p1)->function(p1, p2, p3); } #define HookDefine4(ret, function, t1, p1, t2, p2, t3, p3, t4, p4) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4) \ { return CoreDisp(p1)->function(p1, p2, p3, p4); } #define HookDefine5(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \ { return CoreDisp(p1)->function(p1, p2, p3, p4, p5); } #define HookDefine6(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \ { return CoreDisp(p1)->function(p1, p2, p3, p4, p5, p6); } #define HookDefine7(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \ { return CoreDisp(p1)->function(p1, p2, p3, p4, p5, p6, p7); } #define HookDefine8(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8) \ - ret VKAPI CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \ + ret VKAPI_CALL CONCAT(hooked_, function)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \ { return CoreDisp(p1)->function(p1, p2, p3, p4, p5, p6, p7, p8); } DefineHooks(); @@ -82,16 +82,16 @@ DefineHooks(); // need to implement vkCreateInstance and vkDestroyInstance specially, // to create and destroy the core WrappedVulkan object -VkResult hooked_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) +VkResult hooked_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { WrappedVulkan *core = new WrappedVulkan(""); - return core->vkCreateInstance(pCreateInfo, pInstance); + return core->vkCreateInstance(pCreateInfo, pAllocator, pInstance); } -void hooked_vkDestroyInstance(VkInstance instance) +void hooked_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { WrappedVulkan *core = CoreDisp(instance); - core->vkDestroyInstance(instance); + core->vkDestroyInstance(instance, pAllocator); delete core; } @@ -99,7 +99,7 @@ void hooked_vkDestroyInstance(VkInstance instance) static const VkLayerProperties physLayers[] = { { - "RenderDoc", + "VK_LAYER_RENDERDOC_Capture", VK_API_VERSION, VK_MAKE_VERSION(RENDERDOC_VERSION_MAJOR, RENDERDOC_VERSION_MINOR, 0), "Debugging capture layer for RenderDoc", @@ -115,7 +115,7 @@ static const VkExtensionProperties physExts[] = { static const VkLayerProperties globalLayers[] = { { - "RenderDoc", + "VK_LAYER_RENDERDOC_Capture", VK_API_VERSION, VK_MAKE_VERSION(RENDERDOC_VERSION_MAJOR, RENDERDOC_VERSION_MINOR, 0), "Debugging capture layer for RenderDoc", @@ -144,21 +144,21 @@ VkResult getProps(uint32_t *dstCount, void *dstProps, uint32_t srcCount, void *s extern "C" { -VK_LAYER_EXPORT VkResult VKAPI RenderDocEnumerateDeviceLayerProperties( +VK_LAYER_EXPORT VkResult VKAPI_CALL RenderDocEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, - uint32_t* pCount, + uint32_t* pPropertyCount, VkLayerProperties* pProperties) { - return getProps(pCount, pProperties, ARRAY_COUNT(physLayers), (void *)physLayers, sizeof(VkLayerProperties)); + return getProps(pPropertyCount, pProperties, ARRAY_COUNT(physLayers), (void *)physLayers, sizeof(VkLayerProperties)); } -VK_LAYER_EXPORT VkResult VKAPI RenderDocEnumerateDeviceExtensionProperties( +VK_LAYER_EXPORT VkResult VKAPI_CALL RenderDocEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char *pLayerName, - uint32_t *pCount, + uint32_t *pPropertyCount, VkExtensionProperties *pProperties) { - return getProps(pCount, pProperties, ARRAY_COUNT(physExts), (void *)physExts, sizeof(VkExtensionProperties)); + return getProps(pPropertyCount, pProperties, ARRAY_COUNT(physExts), (void *)physExts, sizeof(VkExtensionProperties)); } #undef HookInit @@ -166,7 +166,7 @@ VK_LAYER_EXPORT VkResult VKAPI RenderDocEnumerateDeviceExtensionProperties( // proc addr routines -VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI RenderDoc_GetDeviceProcAddr(VkDevice device, const char* pName) +VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI_CALL RenderDoc_GetDeviceProcAddr(VkDevice device, const char* pName) { if (device == NULL) return NULL; @@ -189,7 +189,7 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI RenderDoc_GetDeviceProcAddr(VkDevice de return GetDeviceDispatchTable(device)->GetDeviceProcAddr(device, pName); } -VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI RenderDoc_GetInstanceProcAddr(VkInstance instance, const char* pName) +VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI_CALL RenderDoc_GetInstanceProcAddr(VkInstance instance, const char* pName) { if (instance == NULL) return NULL;