vulkan.h: Change return types of some functions to void
Functions that should be thought of as "impossible to fail in the face
of valid parameters" have had their return types changed to void.
This includes all of the vkDestroy functions, vkFreeMemory, and vkUnmapMemory.
vkUpdateDescriptorSets is also included, because of the frequency the function
is expected to be called.
diff --git a/include/vulkan.h b/include/vulkan.h
index 23c6805..a9dbbf4 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -2089,7 +2089,7 @@
typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
-typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
+typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
@@ -2100,7 +2100,7 @@
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
-typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
+typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
@@ -2110,9 +2110,9 @@
typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
-typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
+typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
-typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
+typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
@@ -2126,77 +2126,77 @@
typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
-typedef VkResult (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
+typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
-typedef VkResult (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
+typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore);
typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore);
typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
-typedef VkResult (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
+typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
-typedef VkResult (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
+typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);
typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
-typedef VkResult (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
+typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
-typedef VkResult (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
+typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
-typedef VkResult (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
+typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
-typedef VkResult (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
+typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
-typedef VkResult (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule);
+typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule);
typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
-typedef VkResult (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
+typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
-typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
+typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache);
typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData);
typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
-typedef VkResult (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
+typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
-typedef VkResult (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
+typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
-typedef VkResult (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler);
+typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler);
typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
-typedef VkResult (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
+typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
-typedef VkResult (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
+typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets);
typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
-typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState);
+typedef void (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState);
typedef VkResult (VKAPI *PFN_vkCreateDynamicLineWidthState)(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicLineWidthState)(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState);
+typedef void (VKAPI *PFN_vkDestroyDynamicLineWidthState)(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState);
typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthBiasState)(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthBiasState)(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState);
+typedef void (VKAPI *PFN_vkDestroyDynamicDepthBiasState)(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState);
typedef VkResult (VKAPI *PFN_vkCreateDynamicBlendState)(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicBlendState)(VkDevice device, VkDynamicBlendState dynamicBlendState);
+typedef void (VKAPI *PFN_vkDestroyDynamicBlendState)(VkDevice device, VkDynamicBlendState dynamicBlendState);
typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthBoundsState)(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthBoundsState)(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState);
+typedef void (VKAPI *PFN_vkDestroyDynamicDepthBoundsState)(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState);
typedef VkResult (VKAPI *PFN_vkCreateDynamicStencilState)(VkDevice device, const VkDynamicStencilStateCreateInfo* pCreateInfoFront, const VkDynamicStencilStateCreateInfo* pCreateInfoBack, VkDynamicStencilState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicStencilState)(VkDevice device, VkDynamicStencilState dynamicStencilState);
+typedef void (VKAPI *PFN_vkDestroyDynamicStencilState)(VkDevice device, VkDynamicStencilState dynamicStencilState);
typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
-typedef VkResult (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
+typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
-typedef VkResult (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
+typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
-typedef VkResult (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
+typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
-typedef VkResult (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer);
+typedef void (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer);
typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
@@ -2248,7 +2248,7 @@
const VkInstanceCreateInfo* pCreateInfo,
VkInstance* pInstance);
-VkResult VKAPI vkDestroyInstance(
+void VKAPI vkDestroyInstance(
VkInstance instance);
VkResult VKAPI vkEnumeratePhysicalDevices(
@@ -2299,7 +2299,7 @@
const VkDeviceCreateInfo* pCreateInfo,
VkDevice* pDevice);
-VkResult VKAPI vkDestroyDevice(
+void VKAPI vkDestroyDevice(
VkDevice device);
VkResult VKAPI vkGetGlobalExtensionProperties(
@@ -2345,7 +2345,7 @@
const VkMemoryAllocInfo* pAllocInfo,
VkDeviceMemory* pMem);
-VkResult VKAPI vkFreeMemory(
+void VKAPI vkFreeMemory(
VkDevice device,
VkDeviceMemory mem);
@@ -2357,7 +2357,7 @@
VkMemoryMapFlags flags,
void** ppData);
-VkResult VKAPI vkUnmapMemory(
+void VKAPI vkUnmapMemory(
VkDevice device,
VkDeviceMemory mem);
@@ -2437,7 +2437,7 @@
const VkFenceCreateInfo* pCreateInfo,
VkFence* pFence);
-VkResult VKAPI vkDestroyFence(
+void VKAPI vkDestroyFence(
VkDevice device,
VkFence fence);
@@ -2462,7 +2462,7 @@
const VkSemaphoreCreateInfo* pCreateInfo,
VkSemaphore* pSemaphore);
-VkResult VKAPI vkDestroySemaphore(
+void VKAPI vkDestroySemaphore(
VkDevice device,
VkSemaphore semaphore);
@@ -2479,7 +2479,7 @@
const VkEventCreateInfo* pCreateInfo,
VkEvent* pEvent);
-VkResult VKAPI vkDestroyEvent(
+void VKAPI vkDestroyEvent(
VkDevice device,
VkEvent event);
@@ -2500,7 +2500,7 @@
const VkQueryPoolCreateInfo* pCreateInfo,
VkQueryPool* pQueryPool);
-VkResult VKAPI vkDestroyQueryPool(
+void VKAPI vkDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool);
@@ -2518,7 +2518,7 @@
const VkBufferCreateInfo* pCreateInfo,
VkBuffer* pBuffer);
-VkResult VKAPI vkDestroyBuffer(
+void VKAPI vkDestroyBuffer(
VkDevice device,
VkBuffer buffer);
@@ -2527,7 +2527,7 @@
const VkBufferViewCreateInfo* pCreateInfo,
VkBufferView* pView);
-VkResult VKAPI vkDestroyBufferView(
+void VKAPI vkDestroyBufferView(
VkDevice device,
VkBufferView bufferView);
@@ -2536,7 +2536,7 @@
const VkImageCreateInfo* pCreateInfo,
VkImage* pImage);
-VkResult VKAPI vkDestroyImage(
+void VKAPI vkDestroyImage(
VkDevice device,
VkImage image);
@@ -2551,7 +2551,7 @@
const VkImageViewCreateInfo* pCreateInfo,
VkImageView* pView);
-VkResult VKAPI vkDestroyImageView(
+void VKAPI vkDestroyImageView(
VkDevice device,
VkImageView imageView);
@@ -2560,7 +2560,7 @@
const VkShaderModuleCreateInfo* pCreateInfo,
VkShaderModule* pShaderModule);
-VkResult VKAPI vkDestroyShaderModule(
+void VKAPI vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule);
@@ -2569,7 +2569,7 @@
const VkShaderCreateInfo* pCreateInfo,
VkShader* pShader);
-VkResult VKAPI vkDestroyShader(
+void VKAPI vkDestroyShader(
VkDevice device,
VkShader shader);
@@ -2578,7 +2578,7 @@
const VkPipelineCacheCreateInfo* pCreateInfo,
VkPipelineCache* pPipelineCache);
-VkResult VKAPI vkDestroyPipelineCache(
+void VKAPI vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache);
@@ -2611,7 +2611,7 @@
const VkComputePipelineCreateInfo* pCreateInfos,
VkPipeline* pPipelines);
-VkResult VKAPI vkDestroyPipeline(
+void VKAPI vkDestroyPipeline(
VkDevice device,
VkPipeline pipeline);
@@ -2620,7 +2620,7 @@
const VkPipelineLayoutCreateInfo* pCreateInfo,
VkPipelineLayout* pPipelineLayout);
-VkResult VKAPI vkDestroyPipelineLayout(
+void VKAPI vkDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout);
@@ -2629,7 +2629,7 @@
const VkSamplerCreateInfo* pCreateInfo,
VkSampler* pSampler);
-VkResult VKAPI vkDestroySampler(
+void VKAPI vkDestroySampler(
VkDevice device,
VkSampler sampler);
@@ -2638,7 +2638,7 @@
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayout* pSetLayout);
-VkResult VKAPI vkDestroyDescriptorSetLayout(
+void VKAPI vkDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout);
@@ -2649,7 +2649,7 @@
const VkDescriptorPoolCreateInfo* pCreateInfo,
VkDescriptorPool* pDescriptorPool);
-VkResult VKAPI vkDestroyDescriptorPool(
+void VKAPI vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool);
@@ -2671,7 +2671,7 @@
uint32_t count,
const VkDescriptorSet* pDescriptorSets);
-VkResult VKAPI vkUpdateDescriptorSets(
+void VKAPI vkUpdateDescriptorSets(
VkDevice device,
uint32_t writeCount,
const VkWriteDescriptorSet* pDescriptorWrites,
@@ -2683,7 +2683,7 @@
const VkDynamicViewportStateCreateInfo* pCreateInfo,
VkDynamicViewportState* pState);
-VkResult VKAPI vkDestroyDynamicViewportState(
+void VKAPI vkDestroyDynamicViewportState(
VkDevice device,
VkDynamicViewportState dynamicViewportState);
@@ -2692,7 +2692,7 @@
const VkDynamicLineWidthStateCreateInfo* pCreateInfo,
VkDynamicLineWidthState* pState);
-VkResult VKAPI vkDestroyDynamicLineWidthState(
+void VKAPI vkDestroyDynamicLineWidthState(
VkDevice device,
VkDynamicLineWidthState dynamicLineWidthState);
@@ -2701,7 +2701,7 @@
const VkDynamicDepthBiasStateCreateInfo* pCreateInfo,
VkDynamicDepthBiasState* pState);
-VkResult VKAPI vkDestroyDynamicDepthBiasState(
+void VKAPI vkDestroyDynamicDepthBiasState(
VkDevice device,
VkDynamicDepthBiasState dynamicDepthBiasState);
@@ -2710,7 +2710,7 @@
const VkDynamicBlendStateCreateInfo* pCreateInfo,
VkDynamicBlendState* pState);
-VkResult VKAPI vkDestroyDynamicBlendState(
+void VKAPI vkDestroyDynamicBlendState(
VkDevice device,
VkDynamicBlendState dynamicBlendState);
@@ -2719,7 +2719,7 @@
const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo,
VkDynamicDepthBoundsState* pState);
-VkResult VKAPI vkDestroyDynamicDepthBoundsState(
+void VKAPI vkDestroyDynamicDepthBoundsState(
VkDevice device,
VkDynamicDepthBoundsState dynamicDepthBoundsState);
@@ -2729,7 +2729,7 @@
const VkDynamicStencilStateCreateInfo* pCreateInfoBack,
VkDynamicStencilState* pState);
-VkResult VKAPI vkDestroyDynamicStencilState(
+void VKAPI vkDestroyDynamicStencilState(
VkDevice device,
VkDynamicStencilState dynamicStencilState);
@@ -2738,7 +2738,7 @@
const VkFramebufferCreateInfo* pCreateInfo,
VkFramebuffer* pFramebuffer);
-VkResult VKAPI vkDestroyFramebuffer(
+void VKAPI vkDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer);
@@ -2747,7 +2747,7 @@
const VkRenderPassCreateInfo* pCreateInfo,
VkRenderPass* pRenderPass);
-VkResult VKAPI vkDestroyRenderPass(
+void VKAPI vkDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass);
@@ -2761,7 +2761,7 @@
const VkCmdPoolCreateInfo* pCreateInfo,
VkCmdPool* pCmdPool);
-VkResult VKAPI vkDestroyCommandPool(
+void VKAPI vkDestroyCommandPool(
VkDevice device,
VkCmdPool cmdPool);
@@ -2775,7 +2775,7 @@
const VkCmdBufferCreateInfo* pCreateInfo,
VkCmdBuffer* pCmdBuffer);
-VkResult VKAPI vkDestroyCommandBuffer(
+void VKAPI vkDestroyCommandBuffer(
VkDevice device,
VkCmdBuffer commandBuffer);
diff --git a/layers/basic.cpp b/layers/basic.cpp
index f060bb8..822646f 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -107,21 +107,19 @@
}
/* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT VkResult VKAPI basic_DestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device)
{
dispatch_key key = get_dispatch_key(device);
- VkResult res = device_dispatch_table(device)->DestroyDevice(device);
+ device_dispatch_table(device)->DestroyDevice(device);
destroy_device_dispatch_table(key);
- return res;
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT VkResult VKAPI basic_DestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance)
{
dispatch_key key = get_dispatch_key(instance);
- VkResult res = instance_dispatch_table(instance)->DestroyInstance(instance);
+ instance_dispatch_table(instance)->DestroyInstance(instance);
destroy_instance_dispatch_table(key);
- return res;
}
VK_LAYER_EXPORT VkResult VKAPI basic_GetPhysicalDeviceFormatProperties(VkPhysicalDevice gpu, VkFormat format, VkFormatProperties *pFormatInfo)
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index f2e2878..49f5103 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -159,11 +159,11 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
{
dispatch_key key = get_dispatch_key(instance);
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(device_limits_instance_table_map, instance);
- VkResult res = pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance);
// Clean up logging callback, if any
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -175,7 +175,6 @@
layer_data_map.erase(pTable);
instanceMap.erase(instance);
device_limits_instance_table_map.erase(key);
- return res;
}
VK_LAYER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
@@ -330,16 +329,15 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
{
// Free device lifetime allocations
dispatch_key key = get_dispatch_key(device);
VkLayerDispatchTable *pDisp = get_dispatch_table(device_limits_device_table_map, device);
- VkResult result = pDisp->DestroyDevice(device);
+ pDisp->DestroyDevice(device);
deviceExtMap.erase(pDisp);
device_limits_device_table_map.erase(key);
tableDebugMarkerMap.erase(pDisp);
- return result;
}
static const VkLayerProperties ds_global_layers[] = {
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index d660e40..8b3b873 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1330,11 +1330,11 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
{
dispatch_key key = get_dispatch_key(instance);
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map, instance);
- VkResult res = pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance);
// Clean up logging callback, if any
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -1346,7 +1346,6 @@
layer_data_map.erase(pTable);
draw_state_instance_table_map.erase(key);
- return res;
}
static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
@@ -1379,7 +1378,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
{
// Free all the memory
loader_platform_thread_lock_mutex(&globalLock);
@@ -1395,11 +1394,10 @@
dispatch_key key = get_dispatch_key(device);
VkLayerDispatchTable *pDisp = get_dispatch_table(draw_state_device_table_map, device);
- VkResult result = pDisp->DestroyDevice(device);
+ pDisp->DestroyDevice(device);
deviceExtMap.erase(pDisp);
draw_state_device_table_map.erase(key);
tableDebugMarkerMap.erase(pDisp);
- return result;
}
static const VkLayerProperties ds_global_layers[] = {
@@ -1493,172 +1491,148 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyFence(device, fence);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyFence(device, fence);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroySemaphore(device, semaphore);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroySemaphore(device, semaphore);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyEvent(device, event);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyEvent(device, event);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyQueryPool(device, queryPool);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyQueryPool(device, queryPool);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyBuffer(device, buffer);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyBuffer(device, buffer);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyBufferView(device, bufferView);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyBufferView(device, bufferView);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyImage(device, image);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyImage(device, image);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyImageView(device, imageView);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyImageView(device, imageView);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyShaderModule(device, shaderModule);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyShaderModule(device, shaderModule);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyShader(device, shader);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyShader(device, shader);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyPipeline(device, pipeline);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyPipeline(device, pipeline);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroySampler(device, sampler);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroySampler(device, sampler);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicViewportState(device, dynamicViewportState);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicViewportState(device, dynamicViewportState);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyCommandBuffer(device, commandBuffer);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyCommandBuffer(device, commandBuffer);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyFramebuffer(device, framebuffer);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyFramebuffer(device, framebuffer);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyRenderPass(device, renderPass);
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyRenderPass(device, renderPass);
// TODO : Clean up any internal data structures using this obj.
- return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
@@ -1696,12 +1670,11 @@
return result;
}
-VkResult VKAPI vkDestroyPipelineCache(
+void VKAPI vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyPipelineCache(device, pipelineCache);
- return result;
+ get_dispatch_table(draw_state_device_table_map, device)->DestroyPipelineCache(device, pipelineCache);
}
size_t VKAPI vkGetPipelineCacheSize(
@@ -1930,13 +1903,12 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
if (dsUpdate(device, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, writeCount, pDescriptorWrites) &&
dsUpdate(device, VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, copyCount, pDescriptorCopies)) {
- return get_dispatch_table(draw_state_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
+ get_dispatch_table(draw_state_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
}
- return VK_ERROR_UNKNOWN;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState)
diff --git a/layers/image.cpp b/layers/image.cpp
index bd5f9d8..de15789 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -145,12 +145,12 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(image_instance_table_map, instance);
- VkResult result = pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance);
// Clean up logging callback, if any
layer_data *data = get_my_data_ptr(key, layer_data_map);
@@ -164,8 +164,6 @@
image_instance_table_map.erase(key);
assert(image_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
-
- return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
@@ -183,7 +181,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
{
layer_debug_report_destroy_device(device);
@@ -192,11 +190,9 @@
fprintf(stderr, "Device: %p, key: %p\n", device, key);
#endif
- VkResult result = get_dispatch_table(image_device_table_map, device)->DestroyDevice(device);
+ get_dispatch_table(image_device_table_map, device)->DestroyDevice(device);
image_device_table_map.erase(key);
assert(image_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
-
- return result;
}
static const VkLayerProperties pc_global_layers[] = {
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 7fa6e4c..e0b4305 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1332,12 +1332,12 @@
}
// hook DestroyInstance to remove tableInstanceMap entry
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(mem_tracker_instance_table_map, instance);
- VkResult res = pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance);
// Clean up logging callback, if any
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -1350,7 +1350,6 @@
mem_tracker_instance_table_map.erase(key);
assert(mem_tracker_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
- return res;
}
VkResult VKAPI vkCreateInstance(
@@ -1399,7 +1398,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
VkDevice device)
{
loader_platform_thread_lock_mutex(&globalLock);
@@ -1438,11 +1437,9 @@
fprintf(stderr, "Device: %p, key: %p\n", device, key);
#endif
VkLayerDispatchTable *pDisp = get_dispatch_table(mem_tracker_device_table_map, device);
- VkResult result = pDisp->DestroyDevice(device);
+ pDisp->DestroyDevice(device);
mem_tracker_device_table_map.erase(key);
assert(mem_tracker_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
-
- return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
@@ -1560,7 +1557,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(
+VK_LAYER_EXPORT void VKAPI vkFreeMemory(
VkDevice device,
VkDeviceMemory mem)
{
@@ -1579,8 +1576,7 @@
"Freeing memory object while it still has references: mem obj %#" PRIxLEAST64, mem.handle);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->FreeMemory(device, mem);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->FreeMemory(device, mem);
}
VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(
@@ -1604,17 +1600,16 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(
+VK_LAYER_EXPORT void VKAPI vkUnmapMemory(
VkDevice device,
VkDeviceMemory mem)
{
// TODO : Track as memory gets unmapped, do we want to check what changed following map?
// Make sure that memory was ever mapped to begin with
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->UnmapMemory(device, mem);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->UnmapMemory(device, mem);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
{
loader_platform_thread_lock_mutex(&globalLock);
delete_fence_info(fence);
@@ -1623,11 +1618,10 @@
fenceMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyFence(device, fence);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyFence(device, fence);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = bufferMap.find(buffer.handle);
@@ -1635,11 +1629,10 @@
bufferMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyBuffer(device, buffer);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyBuffer(device, buffer);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = imageMap.find(image.handle);
@@ -1647,11 +1640,10 @@
imageMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyImage(device, image);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyImage(device, image);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = imageViewMap.find(imageView.handle);
@@ -1659,11 +1651,10 @@
imageViewMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyImageView(device, imageView);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyImageView(device, imageView);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = pipelineMap.find(pipeline.handle);
@@ -1671,11 +1662,10 @@
pipelineMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyPipeline(device, pipeline);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyPipeline(device, pipeline);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = samplerMap.find(sampler.handle);
@@ -1683,11 +1673,10 @@
samplerMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroySampler(device, sampler);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroySampler(device, sampler);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = semaphoreMap.find(semaphore.handle);
@@ -1695,11 +1684,10 @@
semaphoreMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroySemaphore(device, semaphore);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroySemaphore(device, semaphore);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = eventMap.find(event.handle);
@@ -1707,11 +1695,10 @@
eventMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyEvent(device, event);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyEvent(device, event);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = queryPoolMap.find(queryPool.handle);
@@ -1719,11 +1706,10 @@
queryPoolMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyQueryPool(device, queryPool);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyQueryPool(device, queryPool);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = bufferViewMap.find(bufferView.handle);
@@ -1731,11 +1717,10 @@
bufferViewMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyBufferView(device, bufferView);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyBufferView(device, bufferView);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = shaderModuleMap.find(shaderModule.handle);
@@ -1743,11 +1728,10 @@
shaderModuleMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyShaderModule(device, shaderModule);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyShaderModule(device, shaderModule);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = shaderMap.find(shader.handle);
@@ -1755,11 +1739,10 @@
shaderMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyShader(device, shader);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyShader(device, shader);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = pipelineLayoutMap.find(pipelineLayout.handle);
@@ -1767,11 +1750,10 @@
pipelineLayoutMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = descriptorSetLayoutMap.find(descriptorSetLayout.handle);
@@ -1779,11 +1761,10 @@
descriptorSetLayoutMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = descriptorPoolMap.find(descriptorPool.handle);
@@ -1791,11 +1772,10 @@
descriptorPoolMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool);
}
-//VK_LAYER_EXPORT VkResult VKAPI vkDestroyDescriptorSet(VkDevice device, VkDescriptorSet descriptorSet)
+//VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSet(VkDevice device, VkDescriptorSet descriptorSet)
//{
// loader_platform_thread_lock_mutex(&globalLock);
// auto item = descriptorSetMap.find(descriptorSet.handle);
@@ -1807,7 +1787,7 @@
// return result;
//}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = renderPassMap.find(renderPass.handle);
@@ -1815,11 +1795,10 @@
renderPassMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyRenderPass(device, renderPass);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyRenderPass(device, renderPass);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = framebufferMap.find(framebuffer.handle);
@@ -1827,11 +1806,10 @@
framebufferMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyFramebuffer(device, framebuffer);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyFramebuffer(device, framebuffer);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = dynamicViewportStateMap.find(dynamicViewportState.handle);
@@ -1839,11 +1817,10 @@
dynamicViewportStateMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicViewportState(device, dynamicViewportState);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicViewportState(device, dynamicViewportState);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = dynamicLineWidthStateMap.find(dynamicLineWidthState.handle);
@@ -1851,11 +1828,10 @@
dynamicLineWidthStateMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = dynamicDepthBiasStateMap.find(dynamicDepthBiasState.handle);
@@ -1863,11 +1839,10 @@
dynamicDepthBiasStateMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = dynamicBlendStateMap.find(dynamicBlendState.handle);
@@ -1875,11 +1850,10 @@
dynamicBlendStateMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = dynamicDepthBoundsStateMap.find(dynamicDepthBoundsState.handle);
@@ -1887,11 +1861,10 @@
dynamicDepthBoundsStateMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
+VK_LAYER_EXPORT void VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
{
loader_platform_thread_lock_mutex(&globalLock);
auto item = dynamicStencilStateMap.find(dynamicStencilState.handle);
@@ -1899,8 +1872,7 @@
dynamicStencilStateMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
}
VkResult VKAPI vkBindBufferMemory(
diff --git a/layers/multi.cpp b/layers/multi.cpp
index cd4e94f..47b1ba5 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -40,16 +40,15 @@
/******************************** Layer multi1 functions **************************/
/* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT VkResult VKAPI multi1DestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
dispatch_key key = get_dispatch_key(device);
printf("At start of multi1 layer vkDestroyDevice()\n");
- VkResult res = pDisp->DestroyDevice(device);
+ pDisp->DestroyDevice(device);
multi1_device_table_map.erase(key);
printf("Completed multi1 layer vkDestroyDevice()\n");
- return res;
}
VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
@@ -144,16 +143,15 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT VkResult VKAPI multi2DestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance)
{
VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(multi2_instance_table_map, instance);
dispatch_key key = get_dispatch_key(instance);
printf("At start of wrapped multi2 vkDestroyInstance()\n");
- VkResult res = pDisp->DestroyInstance(instance);
+ pDisp->DestroyInstance(instance);
multi2_instance_table_map.erase(key);
printf("Completed multi2 layer vkDestroyInstance()\n");
- return res;
}
VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI multi2GetInstanceProcAddr(VkInstance inst, const char* pName)
diff --git a/layers/object_track.h b/layers/object_track.h
index ca957fb..f645557 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -629,7 +629,7 @@
return result;
}
-VkResult
+void
explicit_UnmapMemory(
VkDevice device,
VkDeviceMemory mem)
@@ -639,9 +639,7 @@
validate_object(device, device);
loader_platform_thread_unlock_mutex(&objLock);
- VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->UnmapMemory(device, mem);
-
- return result;
+ get_dispatch_table(ObjectTracker_device_table_map, device)->UnmapMemory(device, mem);
}
VkResult
@@ -774,7 +772,7 @@
return result;
}
-VkResult
+void
explicit_FreeMemory(
VkDevice device,
VkDeviceMemory mem)
@@ -783,13 +781,11 @@
validate_object(device, device);
loader_platform_thread_unlock_mutex(&objLock);
- VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->FreeMemory(device, mem);
+ get_dispatch_table(ObjectTracker_device_table_map, device)->FreeMemory(device, mem);
loader_platform_thread_lock_mutex(&objLock);
destroy_obj(device, mem);
loader_platform_thread_unlock_mutex(&objLock);
-
- return result;
}
VkResult
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 3281ee2..308f983 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1930,13 +1930,13 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(
VkInstance instance)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
- VkResult result = pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance);
// Clean up logging callback, if any
layer_data *data = get_my_data_ptr(key, layer_data_map);
@@ -1950,8 +1950,6 @@
pc_instance_table_map.erase(key);
assert(pc_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
-
- return result;
}
bool PostEnumeratePhysicalDevices(
@@ -2257,7 +2255,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
VkDevice device)
{
layer_debug_report_destroy_device(device);
@@ -2267,11 +2265,9 @@
fprintf(stderr, "Device: %p, key: %p\n", device, key);
#endif
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device);
+ get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device);
pc_device_table_map.erase(key);
assert(pc_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
-
- return result;
}
bool PostGetDeviceQueue(
@@ -2457,34 +2453,6 @@
return result;
}
-bool PostFreeMemory(
- VkDevice device,
- VkDeviceMemory mem,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkFreeMemory parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(
- VkDevice device,
- VkDeviceMemory mem)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->FreeMemory(device, mem);
-
- PostFreeMemory(device, mem, result);
-
- return result;
-}
-
bool PostMapMemory(
VkDevice device,
VkDeviceMemory mem,
@@ -2528,34 +2496,6 @@
return result;
}
-bool PostUnmapMemory(
- VkDevice device,
- VkDeviceMemory mem,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkUnmapMemory parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(
- VkDevice device,
- VkDeviceMemory mem)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->UnmapMemory(device, mem);
-
- PostUnmapMemory(device, mem, result);
-
- return result;
-}
-
bool PreFlushMappedMemoryRanges(
VkDevice device,
const VkMappedMemoryRange* pMemRanges)
@@ -3142,34 +3082,6 @@
return result;
}
-bool PostDestroyFence(
- VkDevice device,
- VkFence fence,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyFence parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyFence(
- VkDevice device,
- VkFence fence)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyFence(device, fence);
-
- PostDestroyFence(device, fence, result);
-
- return result;
-}
-
bool PreResetFences(
VkDevice device,
const VkFence* pFences)
@@ -3339,34 +3251,6 @@
return result;
}
-bool PostDestroySemaphore(
- VkDevice device,
- VkSemaphore semaphore,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroySemaphore parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySemaphore(
- VkDevice device,
- VkSemaphore semaphore)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroySemaphore(device, semaphore);
-
- PostDestroySemaphore(device, semaphore, result);
-
- return result;
-}
-
bool PostQueueSignalSemaphore(
VkQueue queue,
VkSemaphore semaphore,
@@ -3474,34 +3358,6 @@
return result;
}
-bool PostDestroyEvent(
- VkDevice device,
- VkEvent event,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyEvent parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyEvent(
- VkDevice device,
- VkEvent event)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyEvent(device, event);
-
- PostDestroyEvent(device, event, result);
-
- return result;
-}
-
bool PostGetEventStatus(
VkDevice device,
VkEvent event,
@@ -3644,34 +3500,6 @@
return result;
}
-bool PostDestroyQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyQueryPool parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyQueryPool(
- VkDevice device,
- VkQueryPool queryPool)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyQueryPool(device, queryPool);
-
- PostDestroyQueryPool(device, queryPool, result);
-
- return result;
-}
-
bool PostGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
@@ -3782,34 +3610,6 @@
return result;
}
-bool PostDestroyBuffer(
- VkDevice device,
- VkBuffer buffer,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyBuffer parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyBuffer(
- VkDevice device,
- VkBuffer buffer)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyBuffer(device, buffer);
-
- PostDestroyBuffer(device, buffer, result);
-
- return result;
-}
-
bool PreCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo)
@@ -3875,34 +3675,6 @@
return result;
}
-bool PostDestroyBufferView(
- VkDevice device,
- VkBufferView bufferView,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyBufferView parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyBufferView(
- VkDevice device,
- VkBufferView bufferView)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyBufferView(device, bufferView);
-
- PostDestroyBufferView(device, bufferView, result);
-
- return result;
-}
-
bool PreCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo)
@@ -3985,34 +3757,6 @@
return result;
}
-bool PostDestroyImage(
- VkDevice device,
- VkImage image,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyImage parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyImage(
- VkDevice device,
- VkImage image)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyImage(device, image);
-
- PostDestroyImage(device, image, result);
-
- return result;
-}
-
bool PreGetImageSubresourceLayout(
VkDevice device,
const VkImageSubresource* pSubresource)
@@ -4168,62 +3912,6 @@
return result;
}
-bool PostDestroyImageView(
- VkDevice device,
- VkImageView imageView,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyImageView parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyImageView(
- VkDevice device,
- VkImageView imageView)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyImageView(device, imageView);
-
- PostDestroyImageView(device, imageView, result);
-
- return result;
-}
-
-bool PostDestroyShaderModule(
- VkDevice device,
- VkShaderModule shaderModule,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyShaderModule parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyShaderModule(
- VkDevice device,
- VkShaderModule shaderModule)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyShaderModule(device, shaderModule);
-
- PostDestroyShaderModule(device, shaderModule, result);
-
- return result;
-}
-
bool PreCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo)
@@ -4278,34 +3966,6 @@
return result;
}
-bool PostDestroyShader(
- VkDevice device,
- VkShader shader,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyShader parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyShader(
- VkDevice device,
- VkShader shader)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyShader(device, shader);
-
- PostDestroyShader(device, shader, result);
-
- return result;
-}
-
bool PreCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo)
@@ -4360,34 +4020,6 @@
return result;
}
-bool PostDestroyPipelineCache(
- VkDevice device,
- VkPipelineCache pipelineCache,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyPipelineCache parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyPipelineCache(
- VkDevice device,
- VkPipelineCache pipelineCache)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyPipelineCache(device, pipelineCache);
-
- PostDestroyPipelineCache(device, pipelineCache, result);
-
- return result;
-}
-
bool PostGetPipelineCacheSize(
VkDevice device,
VkPipelineCache pipelineCache)
@@ -4888,34 +4520,6 @@
return result;
}
-bool PostDestroyPipeline(
- VkDevice device,
- VkPipeline pipeline,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyPipeline parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyPipeline(
- VkDevice device,
- VkPipeline pipeline)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyPipeline(device, pipeline);
-
- PostDestroyPipeline(device, pipeline, result);
-
- return result;
-}
-
bool PreCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo)
@@ -4973,34 +4577,6 @@
return result;
}
-bool PostDestroyPipelineLayout(
- VkDevice device,
- VkPipelineLayout pipelineLayout,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyPipelineLayout parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyPipelineLayout(
- VkDevice device,
- VkPipelineLayout pipelineLayout)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout);
-
- PostDestroyPipelineLayout(device, pipelineLayout, result);
-
- return result;
-}
-
bool PreCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo)
@@ -5108,34 +4684,6 @@
return result;
}
-bool PostDestroySampler(
- VkDevice device,
- VkSampler sampler,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroySampler parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySampler(
- VkDevice device,
- VkSampler sampler)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroySampler(device, sampler);
-
- PostDestroySampler(device, sampler, result);
-
- return result;
-}
-
bool PreCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
@@ -5200,34 +4748,6 @@
return result;
}
-bool PostDestroyDescriptorSetLayout(
- VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDescriptorSetLayout parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDescriptorSetLayout(
- VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout);
-
- PostDestroyDescriptorSetLayout(device, descriptorSetLayout, result);
-
- return result;
-}
-
bool PreCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo)
@@ -5302,34 +4822,6 @@
return result;
}
-bool PostDestroyDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDescriptorPool parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool);
-
- PostDestroyDescriptorPool(device, descriptorPool, result);
-
- return result;
-}
-
bool PostResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
@@ -5509,26 +5001,7 @@
return true;
}
-bool PostUpdateDescriptorSets(
- VkDevice device,
- uint32_t writeCount,
- uint32_t copyCount,
- VkResult result)
-{
-
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkUpdateDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptorSets(
VkDevice device,
uint32_t writeCount,
const VkWriteDescriptorSet* pDescriptorWrites,
@@ -5537,11 +5010,7 @@
{
PreUpdateDescriptorSets(device, pDescriptorWrites, pDescriptorCopies);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
-
- PostUpdateDescriptorSets(device, writeCount, copyCount, result);
-
- return result;
+ get_dispatch_table(pc_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
}
bool PreCreateDynamicViewportState(
@@ -5601,34 +5070,6 @@
return result;
}
-bool PostDestroyDynamicViewportState(
- VkDevice device,
- VkDynamicViewportState dynamicViewportState,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDynamicViewportState parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(
- VkDevice device,
- VkDynamicViewportState dynamicViewportState)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicViewportState(device, dynamicViewportState);
-
- PostDestroyDynamicViewportState(device, dynamicViewportState, result);
-
- return result;
-}
-
bool PreCreateDynamicLineWidthState(
VkDevice device,
const VkDynamicLineWidthStateCreateInfo* pCreateInfo)
@@ -5680,34 +5121,6 @@
return result;
}
-bool PostDestroyDynamicLineWidthState(
- VkDevice device,
- VkDynamicLineWidthState dynamicLineWidthState,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDynamicLineWidthState parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(
- VkDevice device,
- VkDynamicLineWidthState dynamicLineWidthState)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
-
- PostDestroyDynamicLineWidthState(device, dynamicLineWidthState, result);
-
- return result;
-}
-
bool PreCreateDynamicDepthBiasState(
VkDevice device,
const VkDynamicDepthBiasStateCreateInfo* pCreateInfo)
@@ -5759,34 +5172,6 @@
return result;
}
-bool PostDestroyDynamicDepthBiasState(
- VkDevice device,
- VkDynamicDepthBiasState dynamicDepthBiasState,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDynamicDepthBiasState parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(
- VkDevice device,
- VkDynamicDepthBiasState dynamicDepthBiasState)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
-
- PostDestroyDynamicDepthBiasState(device, dynamicDepthBiasState, result);
-
- return result;
-}
-
bool PreCreateDynamicBlendState(
VkDevice device,
const VkDynamicBlendStateCreateInfo* pCreateInfo)
@@ -5838,34 +5223,6 @@
return result;
}
-bool PostDestroyDynamicBlendState(
- VkDevice device,
- VkDynamicBlendState dynamicBlendState,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDynamicBlendState parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(
- VkDevice device,
- VkDynamicBlendState dynamicBlendState)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState);
-
- PostDestroyDynamicBlendState(device, dynamicBlendState, result);
-
- return result;
-}
-
bool PreCreateDynamicDepthBoundsState(
VkDevice device,
const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo)
@@ -5917,32 +5274,6 @@
return result;
}
-bool PostDestroyDynamicDepthBoundsState(
- VkDevice device,
- VkDynamicDepthBoundsState dynamicDepthBoundsState,
- VkResult result)
-{
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDynamicDepthBoundsState parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(
- VkDevice device,
- VkDynamicDepthBoundsState dynamicDepthBoundsState)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
-
- PostDestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState, result);
-
- return result;
-}
-
bool PreCreateDynamicStencilState(
VkDevice device,
const VkDynamicStencilStateCreateInfo* pCreateInfoFront,
@@ -6006,32 +5337,6 @@
return result;
}
-bool PostDestroyDynamicStencilState(
- VkDevice device,
- VkDynamicStencilState dynamicStencilState,
- VkResult result)
-{
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyDynamicStencilState parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicStencilState(
- VkDevice device,
- VkDynamicStencilState dynamicStencilState)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicStencilState(device, dynamicStencilState);
-
- PostDestroyDynamicStencilState(device, dynamicStencilState, result);
-
- return result;
-}
-
bool PreCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo)
@@ -6086,34 +5391,6 @@
return result;
}
-bool PostDestroyFramebuffer(
- VkDevice device,
- VkFramebuffer framebuffer,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyFramebuffer parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyFramebuffer(
- VkDevice device,
- VkFramebuffer framebuffer)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyFramebuffer(device, framebuffer);
-
- PostDestroyFramebuffer(device, framebuffer, result);
-
- return result;
-}
-
bool PreCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo)
@@ -6295,34 +5572,6 @@
return result;
}
-bool PostDestroyRenderPass(
- VkDevice device,
- VkRenderPass renderPass,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyRenderPass parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyRenderPass(
- VkDevice device,
- VkRenderPass renderPass)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyRenderPass(device, renderPass);
-
- PostDestroyRenderPass(device, renderPass, result);
-
- return result;
-}
-
bool PostGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
@@ -6408,34 +5657,6 @@
return result;
}
-bool PostDestroyCommandPool(
- VkDevice device,
- VkCmdPool cmdPool,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyCommandPool parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyCommandPool(
- VkDevice device,
- VkCmdPool cmdPool)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyCommandPool(device, cmdPool);
-
- PostDestroyCommandPool(device, cmdPool, result);
-
- return result;
-}
-
bool PostResetCommandPool(
VkDevice device,
VkCmdPool cmdPool,
@@ -6525,34 +5746,6 @@
return result;
}
-bool PostDestroyCommandBuffer(
- VkDevice device,
- VkCmdBuffer commandBuffer,
- VkResult result)
-{
-
-
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkDestroyCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
- return true;
-}
-
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyCommandBuffer(
- VkDevice device,
- VkCmdBuffer commandBuffer)
-{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyCommandBuffer(device, commandBuffer);
-
- PostDestroyCommandBuffer(device, commandBuffer, result);
-
- return result;
-}
-
bool PreBeginCommandBuffer(
VkCmdBuffer cmdBuffer,
const VkCmdBufferBeginInfo* pBeginInfo)
@@ -8178,12 +7371,8 @@
return (PFN_vkVoidFunction) vkDeviceWaitIdle;
if (!strcmp(funcName, "vkAllocMemory"))
return (PFN_vkVoidFunction) vkAllocMemory;
- if (!strcmp(funcName, "vkFreeMemory"))
- return (PFN_vkVoidFunction) vkFreeMemory;
if (!strcmp(funcName, "vkMapMemory"))
return (PFN_vkVoidFunction) vkMapMemory;
- if (!strcmp(funcName, "vkUnmapMemory"))
- return (PFN_vkVoidFunction) vkUnmapMemory;
if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
return (PFN_vkVoidFunction) vkFlushMappedMemoryRanges;
if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges"))
@@ -8224,8 +7413,6 @@
return (PFN_vkVoidFunction) vkGetImageSubresourceLayout;
if (!strcmp(funcName, "vkCreateImageView"))
return (PFN_vkVoidFunction) vkCreateImageView;
- if (!strcmp(funcName, "vkDestroyImageView"))
- return (PFN_vkVoidFunction) vkDestroyImageView;
if (!strcmp(funcName, "vkCreateShader"))
return (PFN_vkVoidFunction) vkCreateShader;
if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 5ee3e6c..e8d4b60 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -302,12 +302,9 @@
file.close();
// Clean up
- err = pTableDevice->UnmapMemory(device, mem2);
- assert(!err);
- err = pTableDevice->FreeMemory(device, mem2);
- assert(!err);
- err = pTableDevice->DestroyCommandBuffer(device, cmdBuffer);
- assert(!err);
+ pTableDevice->UnmapMemory(device, mem2);
+ pTableDevice->FreeMemory(device, mem2);
+ pTableDevice->DestroyCommandBuffer(device, cmdBuffer);
}
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 35dd415..7e3602c 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -1004,13 +1004,12 @@
}
/* hook DextroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
{
dispatch_key key = get_dispatch_key(device);
VkLayerDispatchTable *pDisp = get_dispatch_table(shader_checker_device_table_map, device);
- VkResult result = pDisp->DestroyDevice(device);
+ pDisp->DestroyDevice(device);
shader_checker_device_table_map.erase(key);
- return result;
}
VkResult VKAPI vkCreateInstance(
@@ -1034,11 +1033,11 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
{
dispatch_key key = get_dispatch_key(instance);
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(shader_checker_instance_table_map, instance);
- VkResult res = pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance);
// Clean up logging callback, if any
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -1050,7 +1049,6 @@
layer_data_map.erase(pTable);
shader_checker_instance_table_map.erase(key);
- return res;
}
VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
diff --git a/loader/loader.c b/loader/loader.c
index b12a065..a434b59 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -2641,13 +2641,12 @@
return VK_SUCCESS;
}
-VkResult VKAPI loader_DestroyInstance(
+void VKAPI loader_DestroyInstance(
VkInstance instance)
{
struct loader_instance *ptr_instance = loader_instance(instance);
struct loader_icd *icds = ptr_instance->icds;
struct loader_icd *next_icd;
- VkResult res;
// Remove this instance from the list of instances:
struct loader_instance *prev = NULL;
@@ -2672,10 +2671,11 @@
while (icds) {
if (icds->instance) {
- res = icds->DestroyInstance(icds->instance);
- if (res != VK_SUCCESS)
- loader_log(VK_DBG_REPORT_WARN_BIT, 0,
- "ICD ignored: failed to DestroyInstance on device");
+ icds->DestroyInstance(icds->instance);
+ /* TODOVV: Move this test to validation layer */
+ //if (res != VK_SUCCESS)
+ // loader_log(VK_DBG_REPORT_WARN_BIT, 0,
+ // "ICD ignored: failed to DestroyInstance on device");
}
next_icd = icds->next;
icds->instance = VK_NULL_HANDLE;
@@ -2687,7 +2687,6 @@
loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list);
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
loader_destroy_ext_list(ptr_instance, &ptr_instance->ext_list);
- return VK_SUCCESS;
}
VkResult loader_init_physical_device_info(
diff --git a/loader/loader.h b/loader/loader.h
index bcaf998..67fa20e 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -270,7 +270,7 @@
const VkInstanceCreateInfo* pCreateInfo,
VkInstance* pInstance);
-VkResult VKAPI loader_DestroyInstance(
+void VKAPI loader_DestroyInstance(
VkInstance instance);
VkResult VKAPI loader_EnumeratePhysicalDevices(
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 4ca018c..6a9e25b 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -179,24 +179,21 @@
return res;
}
-LOADER_EXPORT VkResult VKAPI vkDestroyInstance(
+LOADER_EXPORT void VKAPI vkDestroyInstance(
VkInstance instance)
{
const VkLayerInstanceDispatchTable *disp;
- VkResult res;
disp = loader_get_instance_dispatch(instance);
loader_platform_thread_lock_mutex(&loader_lock);
- res = disp->DestroyInstance(instance);
+ disp->DestroyInstance(instance);
struct loader_instance *ptr_instance = loader_instance(instance);
loader_deactivate_instance_layers(ptr_instance);
loader_heap_free(ptr_instance, ptr_instance->disp);
loader_heap_free(ptr_instance, ptr_instance);
loader_platform_thread_unlock_mutex(&loader_lock);
-
- return res;
}
LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
@@ -307,20 +304,18 @@
return res;
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
+LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
{
const VkLayerDispatchTable *disp;
- VkResult res;
struct loader_device *dev;
struct loader_icd *icd = loader_get_icd_and_device(device, &dev);
const struct loader_instance *inst = icd->this_instance;
disp = loader_get_dispatch(device);
loader_platform_thread_lock_mutex(&loader_lock);
- res = disp->DestroyDevice(device);
+ disp->DestroyDevice(device);
loader_remove_logical_device(inst, device);
loader_platform_thread_unlock_mutex(&loader_lock);
- return res;
}
LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
@@ -403,13 +398,13 @@
return disp->AllocMemory(device, pAllocInfo, pMem);
}
-LOADER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
+LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->FreeMemory(device, mem);
+ disp->FreeMemory(device, mem);
}
LOADER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData)
@@ -421,13 +416,13 @@
return disp->MapMemory(device, mem, offset, size, flags, ppData);
}
-LOADER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
+LOADER_EXPORT void VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->UnmapMemory(device, mem);
+ disp->UnmapMemory(device, mem);
}
LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges)
@@ -547,13 +542,13 @@
return disp->CreateFence(device, pCreateInfo, pFence);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyFence(device, fence);
+ disp->DestroyFence(device, fence);
}
LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
@@ -592,13 +587,13 @@
return disp->CreateSemaphore(device, pCreateInfo, pSemaphore);
}
-LOADER_EXPORT VkResult VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroySemaphore(device, semaphore);
+ disp->DestroySemaphore(device, semaphore);
}
LOADER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore)
@@ -628,13 +623,13 @@
return disp->CreateEvent(device, pCreateInfo, pEvent);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyEvent(device, event);
+ disp->DestroyEvent(device, event);
}
LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event)
@@ -673,13 +668,13 @@
return disp->CreateQueryPool(device, pCreateInfo, pQueryPool);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyQueryPool(device, queryPool);
+ disp->DestroyQueryPool(device, queryPool);
}
LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags)
@@ -700,13 +695,13 @@
return disp->CreateBuffer(device, pCreateInfo, pBuffer);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyBuffer(device, buffer);
+ disp->DestroyBuffer(device, buffer);
}
LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
@@ -718,13 +713,13 @@
return disp->CreateBufferView(device, pCreateInfo, pView);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyBufferView(device, bufferView);
+ disp->DestroyBufferView(device, bufferView);
}
LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
@@ -736,13 +731,13 @@
return disp->CreateImage(device, pCreateInfo, pImage);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyImage(VkDevice device, VkImage image)
+LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyImage(device, image);
+ disp->DestroyImage(device, image);
}
LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
@@ -763,13 +758,13 @@
return disp->CreateImageView(device, pCreateInfo, pView);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyImageView(device, imageView);
+ disp->DestroyImageView(device, imageView);
}
LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader)
@@ -781,13 +776,13 @@
return disp->CreateShaderModule(device, pCreateInfo, pShader);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyShaderModule(device, shaderModule);
+ disp->DestroyShaderModule(device, shaderModule);
}
LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
@@ -799,13 +794,13 @@
return disp->CreateShader(device, pCreateInfo, pShader);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyShader(device, shader);
+ disp->DestroyShader(device, shader);
}
LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache)
@@ -817,13 +812,13 @@
return disp->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache)
+LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyPipelineCache(device, pipelineCache);
+ disp->DestroyPipelineCache(device, pipelineCache);
}
LOADER_EXPORT size_t VKAPI vkGetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache)
@@ -871,13 +866,13 @@
return disp->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyPipeline(device, pipeline);
+ disp->DestroyPipeline(device, pipeline);
}
LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
@@ -889,13 +884,13 @@
return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyPipelineLayout(device, pipelineLayout);
+ disp->DestroyPipelineLayout(device, pipelineLayout);
}
LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
@@ -907,13 +902,13 @@
return disp->CreateSampler(device, pCreateInfo, pSampler);
}
-LOADER_EXPORT VkResult VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroySampler(device, sampler);
+ disp->DestroySampler(device, sampler);
}
@@ -926,13 +921,13 @@
return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDescriptorSetLayout(device, descriptorSetLayout);
+ disp->DestroyDescriptorSetLayout(device, descriptorSetLayout);
}
LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
@@ -944,13 +939,13 @@
return disp->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDescriptorPool(device, descriptorPool);
+ disp->DestroyDescriptorPool(device, descriptorPool);
}
@@ -981,13 +976,13 @@
return disp->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
}
-LOADER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+LOADER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
+ disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
}
LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState)
@@ -999,13 +994,13 @@
return disp->CreateDynamicViewportState(device, pCreateInfo, pState);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
+LOADER_EXPORT void VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDynamicViewportState(device, dynamicViewportState);
+ disp->DestroyDynamicViewportState(device, dynamicViewportState);
}
LOADER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* pState)
@@ -1017,13 +1012,13 @@
return disp->CreateDynamicLineWidthState(device, pCreateInfo, pState);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
+LOADER_EXPORT void VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
+ disp->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
}
LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState)
@@ -1035,13 +1030,13 @@
return disp->CreateDynamicDepthBiasState(device, pCreateInfo, pState);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
+LOADER_EXPORT void VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
+ disp->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
}
LOADER_EXPORT VkResult VKAPI vkCreateDynamicBlendState(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState)
@@ -1053,13 +1048,13 @@
return disp->CreateDynamicBlendState(device, pCreateInfo, pState);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
+LOADER_EXPORT void VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDynamicBlendState(device, dynamicBlendState);
+ disp->DestroyDynamicBlendState(device, dynamicBlendState);
}
LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState)
@@ -1071,13 +1066,13 @@
return disp->CreateDynamicDepthBoundsState(device, pCreateInfo, pState);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
+LOADER_EXPORT void VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
+ disp->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
}
LOADER_EXPORT VkResult VKAPI vkCreateDynamicStencilState(VkDevice device, const VkDynamicStencilStateCreateInfo* pCreateInfoFront, const VkDynamicStencilStateCreateInfo* pCreateInfoBack, VkDynamicStencilState* pState)
@@ -1089,13 +1084,13 @@
return disp->CreateDynamicStencilState(device, pCreateInfoFront, pCreateInfoBack, pState);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
+LOADER_EXPORT void VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDynamicStencilState(device, dynamicStencilState);
+ disp->DestroyDynamicStencilState(device, dynamicStencilState);
}
LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
@@ -1107,13 +1102,13 @@
return disp->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyFramebuffer(device, framebuffer);
+ disp->DestroyFramebuffer(device, framebuffer);
}
LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
@@ -1125,13 +1120,13 @@
return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyRenderPass(device, renderPass);
+ disp->DestroyRenderPass(device, renderPass);
}
LOADER_EXPORT VkResult VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
@@ -1152,13 +1147,13 @@
return disp->CreateCommandPool(device, pCreateInfo, pCmdPool);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
+LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyCommandPool(device, cmdPool);
+ disp->DestroyCommandPool(device, cmdPool);
}
LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
@@ -1185,13 +1180,13 @@
return res;
}
-LOADER_EXPORT VkResult VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdBuffer)
+LOADER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdBuffer)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyCommandBuffer(device, cmdBuffer);
+ disp->DestroyCommandBuffer(device, cmdBuffer);
}
LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index 2fcffb3..c486b2c 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -821,8 +821,7 @@
EXPECT_EQ(0x11111111, data[0]);
bufs[2].memory().unmap();
- err = vkDestroyEvent(dev_.handle(), event);
- ASSERT_VK_SUCCESS(err);
+ vkDestroyEvent(dev_.handle(), event);
}
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 5630cbd..0cefe69 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -239,12 +239,10 @@
void VkImageTest::DestroyImage()
{
- VkResult err;
// All done with image memory, clean up
- err = vkFreeMemory(device(), m_image_mem);
- ASSERT_VK_SUCCESS(err);
+ vkFreeMemory(device(), m_image_mem);
- ASSERT_VK_SUCCESS(vkDestroyImage(device(), m_image));
+ vkDestroyImage(device(), m_image);
}
void VkImageTest::CreateImageView(VkImageViewCreateInfo *pCreateInfo,
@@ -256,7 +254,7 @@
void VkImageTest::DestroyImageView(VkImageView imageView)
{
- ASSERT_VK_SUCCESS(vkDestroyImageView(device(), imageView));
+ vkDestroyImageView(device(), imageView);
}
TEST_F(VkImageTest, CreateImageViewTest) {
diff --git a/tests/init.cpp b/tests/init.cpp
index b6f9294..a191555 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -165,11 +165,9 @@
memset(pData, 0x55, alloc_info.allocationSize);
EXPECT_EQ(0x55, pData[0]) << "Memory read not same as write";
- err = vkUnmapMemory(device(), gpu_mem);
- ASSERT_VK_SUCCESS(err);
+ vkUnmapMemory(device(), gpu_mem);
- err = vkFreeMemory(device(), gpu_mem);
- ASSERT_VK_SUCCESS(err);
+ vkFreeMemory(device(), gpu_mem);
}
TEST_F(VkTest, Event) {
@@ -204,8 +202,7 @@
// TODO: Test actual synchronization with command buffer event.
// All done with event memory, clean up
- err = vkDestroyEvent(device(), event);
- ASSERT_VK_SUCCESS(err);
+ vkDestroyEvent(device(), event);
}
#define MAX_QUERY_SLOTS 10
@@ -270,8 +267,7 @@
}
- err = vkDestroyQueryPool(device(), query_pool);
- ASSERT_VK_SUCCESS(err);
+ vkDestroyQueryPool(device(), query_pool);
}
void getQueue(vk_testing::Device *device, uint32_t queue_node_index, const char *qname)
@@ -480,11 +476,11 @@
// TODO: Test image memory.
// All done with image memory, clean up
- ASSERT_VK_SUCCESS(vkDestroyImageView(device(), view));
- ASSERT_VK_SUCCESS(vkDestroyImage(device(), image));
+ vkDestroyImageView(device(), view);
+ vkDestroyImage(device(), image);
if (mem_req.size) {
- ASSERT_VK_SUCCESS(vkFreeMemory(device(), image_mem));
+ vkFreeMemory(device(), image_mem);
}
}
@@ -520,8 +516,8 @@
err = vkCreateCommandBuffer(device(), &info, &cmdBuffer);
ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
- ASSERT_VK_SUCCESS(vkDestroyCommandBuffer(device(), cmdBuffer));
- ASSERT_VK_SUCCESS(vkDestroyCommandPool(device(), cmdPool));
+ vkDestroyCommandBuffer(device(), cmdBuffer);
+ vkDestroyCommandPool(device(), cmdPool);
}
TEST_F(VkTest, TestCommandBuffer) {
@@ -568,8 +564,7 @@
err = vkCreateShader(device(), &createInfo, &shader);
ASSERT_VK_SUCCESS(err);
- err = vkDestroyShaderModule(device(), module);
- ASSERT_VK_SUCCESS(err);
+ vkDestroyShaderModule(device(), module);
*pshader = shader;
}
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index f5ee736..867ae18 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -35,11 +35,11 @@
NonDispHandle::init(dev.handle(), handle); \
} while (0)
-#define NON_DISPATCHABLE_HANDLE_DTOR(cls, destroy_func) \
+#define NON_DISPATCHABLE_HANDLE_DTOR(cls, destroy_func) \
cls::~cls() \
{ \
if (initialized()) \
- EXPECT(destroy_func(device(), handle()) == VK_SUCCESS); \
+ destroy_func(device(), handle()); \
}
#define STRINGIFY(x) #x
@@ -263,7 +263,7 @@
queues_[i].clear();
}
- EXPECT(vkDestroyDevice(handle()) == VK_SUCCESS);
+ vkDestroyDevice(handle());
}
void Device::init(std::vector<const char *> &layers, std::vector<const char *> &extensions)
@@ -391,9 +391,9 @@
return err;
}
-VkResult Device::update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies)
+void Device::update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies)
{
- return vkUpdateDescriptorSets(handle(), writes.size(), writes.data(), copies.size(), copies.data());
+ vkUpdateDescriptorSets(handle(), writes.size(), writes.data(), copies.size(), copies.data());
}
void Queue::submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence)
@@ -431,7 +431,7 @@
DeviceMemory::~DeviceMemory()
{
if (initialized())
- EXPECT(vkFreeMemory(device(), handle()) == VK_SUCCESS);
+ vkFreeMemory(device(), handle());
}
void DeviceMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
@@ -459,7 +459,7 @@
void DeviceMemory::unmap() const
{
- EXPECT(vkUnmapMemory(device(), handle()) == VK_SUCCESS);
+ vkUnmapMemory(device(), handle());
}
NON_DISPATCHABLE_HANDLE_DTOR(Fence, vkDestroyFence)
@@ -830,7 +830,7 @@
CmdBuffer::~CmdBuffer()
{
if (initialized())
- EXPECT(vkDestroyCommandBuffer(dev_handle_, handle()) == VK_SUCCESS);
+ vkDestroyCommandBuffer(dev_handle_, handle());
}
void CmdBuffer::init(const Device &dev, const VkCmdBufferCreateInfo &info)
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 57717d5..805bcde 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -184,8 +184,8 @@
VkResult wait(const Fence &fence) { return wait(std::vector<const Fence *>(1, &fence), true, (uint64_t) -1); }
// vkUpdateDescriptorSets()
- VkResult update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies);
- VkResult update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes) { return update_descriptor_sets(writes, std::vector<VkCopyDescriptorSet>()); }
+ void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies);
+ void update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes) { return update_descriptor_sets(writes, std::vector<VkCopyDescriptorSet>()); }
static VkWriteDescriptorSet write_descriptor_set(const DescriptorSet &set, uint32_t binding, uint32_t array_element,
VkDescriptorType type, uint32_t count, const VkDescriptorInfo *descriptors);
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 6410d32..6ac0163 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -646,19 +646,17 @@
'{\n'
' dispatch_key key = get_dispatch_key(device);\n'
' VkLayerDispatchTable *pDisp = device_dispatch_table(device);\n'
- ' VkResult res = pDisp->DestroyDevice(device);\n'
+ ' pDisp->DestroyDevice(device);\n'
' deviceExtMap.erase(pDisp);\n'
' destroy_device_dispatch_table(key);\n'
- ' return res;\n'
'}\n' % (qual, decl))
elif proto.name == "DestroyInstance":
funcs.append('%s' % self.lineinfo.get())
funcs.append('%s%s\n'
'{\n'
' dispatch_key key = get_dispatch_key(instance);\n'
- ' VkResult res = instance_dispatch_table(instance)->DestroyInstance(instance);\n'
+ ' instance_dispatch_table(instance)->DestroyInstance(instance);\n'
' destroy_instance_dispatch_table(key);\n'
- ' return res;\n'
'}\n' % (qual, decl))
else:
funcs.append('%s' % self.lineinfo.get())
@@ -1336,7 +1334,7 @@
def generate_destroy_instance(self):
gedi_txt = []
gedi_txt.append('%s' % self.lineinfo.get())
- gedi_txt.append('VkResult vkDestroyInstance(')
+ gedi_txt.append('void vkDestroyInstance(')
gedi_txt.append('VkInstance instance)')
gedi_txt.append('{')
gedi_txt.append(' loader_platform_thread_lock_mutex(&objLock);')
@@ -1356,7 +1354,7 @@
gedi_txt.append('')
gedi_txt.append(' dispatch_key key = get_dispatch_key(instance);')
gedi_txt.append(' VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, instance);')
- gedi_txt.append(' VkResult result = pInstanceTable->DestroyInstance(instance);')
+ gedi_txt.append(' pInstanceTable->DestroyInstance(instance);')
gedi_txt.append('')
gedi_txt.append(' // Clean up logging callback, if any')
gedi_txt.append(' layer_data *my_data = get_my_data_ptr(key, layer_data_map);')
@@ -1371,7 +1369,6 @@
gedi_txt.append(' assert(ObjectTracker_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");')
gedi_txt.append('')
gedi_txt.append(' loader_platform_thread_unlock_mutex(&objLock);')
- gedi_txt.append(' return result;')
gedi_txt.append('}')
gedi_txt.append('')
return "\n".join(gedi_txt)
@@ -1379,7 +1376,7 @@
def generate_destroy_device(self):
gedd_txt = []
gedd_txt.append('%s' % self.lineinfo.get())
- gedd_txt.append('VkResult vkDestroyDevice(')
+ gedd_txt.append('void vkDestroyDevice(')
gedd_txt.append('VkDevice device)')
gedd_txt.append('{')
gedd_txt.append(' loader_platform_thread_lock_mutex(&objLock);')
@@ -1404,11 +1401,10 @@
gedd_txt.append('')
gedd_txt.append(' dispatch_key key = get_dispatch_key(device);')
gedd_txt.append(' VkLayerDispatchTable *pDisp = get_dispatch_table(ObjectTracker_device_table_map, device);')
- gedd_txt.append(' VkResult result = pDisp->DestroyDevice(device);')
+ gedd_txt.append(' pDisp->DestroyDevice(device);')
gedd_txt.append(' ObjectTracker_device_table_map.erase(key);')
gedd_txt.append(' assert(ObjectTracker_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");')
gedd_txt.append('')
- gedd_txt.append(' return result;')
gedd_txt.append('}')
gedd_txt.append('')
return "\n".join(gedd_txt)
@@ -1524,12 +1520,12 @@
create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n'
if 'Destroy' in proto.name:
destroy_line = ' loader_platform_thread_lock_mutex(&objLock);\n'
- destroy_line += ' if (result == VK_SUCCESS) {\n'
+# destroy_line += ' if (result == VK_SUCCESS) {\n'
if 'DestroyCommandBuffer' in proto.name:
- destroy_line += ' destroy_obj(%s, %s);\n' % (proto.params[-1].name, proto.params[-1].name)
+ destroy_line += ' destroy_obj(%s, %s);\n' % (proto.params[-1].name, proto.params[-1].name)
else:
- destroy_line += ' destroy_obj(%s, %s);\n' % (param0_name, proto.params[-1].name)
- destroy_line += ' }\n'
+ destroy_line += ' destroy_obj(%s, %s);\n' % (param0_name, proto.params[-1].name)
+# destroy_line += ' }\n'
destroy_line += ' loader_platform_thread_unlock_mutex(&objLock);\n'
if len(loop_params) > 0:
if not mutex_unlock:
@@ -1817,7 +1813,6 @@
' VkLayerDispatchTable *pDeviceTable = get_dispatch_table(Threading_%s_table_map, %s);\n' % (table, proto.params[0].name) +
' %spDeviceTable->%s;\n' % (ret_val, proto.c_call()) +
' Threading_device_table_map.erase(key);\n'
- ' return result;\n'
'}\n')
return "\n".join(funcs);
elif proto.name == "DestroyInstance":
@@ -1838,8 +1833,6 @@
' layer_data_map.erase(pInstanceTable);\n'
'\n'
' Threading_instance_table_map.erase(key);\n'
- '\n'
- ' return result;\n'
'}\n')
return "\n".join(funcs);
elif proto.name == "CreateInstance":
diff --git a/vulkan.py b/vulkan.py
index 47c5079..2c06d30 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -221,7 +221,7 @@
[Param("const VkInstanceCreateInfo*", "pCreateInfo"),
Param("VkInstance*", "pInstance")]),
- Proto("VkResult", "DestroyInstance",
+ Proto("void", "DestroyInstance",
[Param("VkInstance", "instance")]),
Proto("VkResult", "EnumeratePhysicalDevices",
@@ -259,7 +259,7 @@
Param("const VkDeviceCreateInfo*", "pCreateInfo"),
Param("VkDevice*", "pDevice")]),
- Proto("VkResult", "DestroyDevice",
+ Proto("void", "DestroyDevice",
[Param("VkDevice", "device")]),
Proto("VkResult", "GetPhysicalDeviceProperties",
@@ -318,7 +318,7 @@
Param("const VkMemoryAllocInfo*", "pAllocInfo"),
Param("VkDeviceMemory*", "pMem")]),
- Proto("VkResult", "FreeMemory",
+ Proto("void", "FreeMemory",
[Param("VkDevice", "device"),
Param("VkDeviceMemory", "mem")]),
@@ -330,7 +330,7 @@
Param("VkMemoryMapFlags", "flags"),
Param("void**", "ppData")]),
- Proto("VkResult", "UnmapMemory",
+ Proto("void", "UnmapMemory",
[Param("VkDevice", "device"),
Param("VkDeviceMemory", "mem")]),
@@ -410,7 +410,7 @@
Param("const VkFenceCreateInfo*", "pCreateInfo"),
Param("VkFence*", "pFence")]),
- Proto("VkResult", "DestroyFence",
+ Proto("void", "DestroyFence",
[Param("VkDevice", "device"),
Param("VkFence", "fence")]),
@@ -435,7 +435,7 @@
Param("const VkSemaphoreCreateInfo*", "pCreateInfo"),
Param("VkSemaphore*", "pSemaphore")]),
- Proto("VkResult", "DestroySemaphore",
+ Proto("void", "DestroySemaphore",
[Param("VkDevice", "device"),
Param("VkSemaphore", "semaphore")]),
@@ -452,7 +452,7 @@
Param("const VkEventCreateInfo*", "pCreateInfo"),
Param("VkEvent*", "pEvent")]),
- Proto("VkResult", "DestroyEvent",
+ Proto("void", "DestroyEvent",
[Param("VkDevice", "device"),
Param("VkEvent", "event")]),
@@ -473,7 +473,7 @@
Param("const VkQueryPoolCreateInfo*", "pCreateInfo"),
Param("VkQueryPool*", "pQueryPool")]),
- Proto("VkResult", "DestroyQueryPool",
+ Proto("void", "DestroyQueryPool",
[Param("VkDevice", "device"),
Param("VkQueryPool", "queryPool")]),
@@ -491,7 +491,7 @@
Param("const VkBufferCreateInfo*", "pCreateInfo"),
Param("VkBuffer*", "pBuffer")]),
- Proto("VkResult", "DestroyBuffer",
+ Proto("void", "DestroyBuffer",
[Param("VkDevice", "device"),
Param("VkBuffer", "buffer")]),
@@ -500,7 +500,7 @@
Param("const VkBufferViewCreateInfo*", "pCreateInfo"),
Param("VkBufferView*", "pView")]),
- Proto("VkResult", "DestroyBufferView",
+ Proto("void", "DestroyBufferView",
[Param("VkDevice", "device"),
Param("VkBufferView", "bufferView")]),
@@ -509,7 +509,7 @@
Param("const VkImageCreateInfo*", "pCreateInfo"),
Param("VkImage*", "pImage")]),
- Proto("VkResult", "DestroyImage",
+ Proto("void", "DestroyImage",
[Param("VkDevice", "device"),
Param("VkImage", "image")]),
@@ -524,7 +524,7 @@
Param("const VkImageViewCreateInfo*", "pCreateInfo"),
Param("VkImageView*", "pView")]),
- Proto("VkResult", "DestroyImageView",
+ Proto("void", "DestroyImageView",
[Param("VkDevice", "device"),
Param("VkImageView", "imageView")]),
@@ -533,7 +533,7 @@
Param("const VkShaderModuleCreateInfo*", "pCreateInfo"),
Param("VkShaderModule*", "pShaderModule")]),
- Proto("VkResult", "DestroyShaderModule",
+ Proto("void", "DestroyShaderModule",
[Param("VkDevice", "device"),
Param("VkShaderModule", "shaderModule")]),
@@ -542,7 +542,7 @@
Param("const VkShaderCreateInfo*", "pCreateInfo"),
Param("VkShader*", "pShader")]),
- Proto("VkResult", "DestroyShader",
+ Proto("void", "DestroyShader",
[Param("VkDevice", "device"),
Param("VkShader", "shader")]),
@@ -551,7 +551,7 @@
Param("const VkPipelineCacheCreateInfo*", "pCreateInfo"),
Param("VkPipelineCache*", "pPipelineCache")]),
- Proto("VkResult", "DestroyPipelineCache",
+ Proto("void", "DestroyPipelineCache",
[Param("VkDevice", "device"),
Param("VkPipelineCache", "pipelineCache")]),
@@ -584,7 +584,7 @@
Param("const VkComputePipelineCreateInfo*", "pCreateInfos"),
Param("VkPipeline*", "pPipelines")]),
- Proto("VkResult", "DestroyPipeline",
+ Proto("void", "DestroyPipeline",
[Param("VkDevice", "device"),
Param("VkPipeline", "pipeline")]),
@@ -593,7 +593,7 @@
Param("const VkPipelineLayoutCreateInfo*", "pCreateInfo"),
Param("VkPipelineLayout*", "pPipelineLayout")]),
- Proto("VkResult", "DestroyPipelineLayout",
+ Proto("void", "DestroyPipelineLayout",
[Param("VkDevice", "device"),
Param("VkPipelineLayout", "pipelineLayout")]),
@@ -602,7 +602,7 @@
Param("const VkSamplerCreateInfo*", "pCreateInfo"),
Param("VkSampler*", "pSampler")]),
- Proto("VkResult", "DestroySampler",
+ Proto("void", "DestroySampler",
[Param("VkDevice", "device"),
Param("VkSampler", "sampler")]),
@@ -611,7 +611,7 @@
Param("const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo"),
Param("VkDescriptorSetLayout*", "pSetLayout")]),
- Proto("VkResult", "DestroyDescriptorSetLayout",
+ Proto("void", "DestroyDescriptorSetLayout",
[Param("VkDevice", "device"),
Param("VkDescriptorSetLayout", "descriptorSetLayout")]),
@@ -622,7 +622,7 @@
Param("const VkDescriptorPoolCreateInfo*", "pCreateInfo"),
Param("VkDescriptorPool*", "pDescriptorPool")]),
- Proto("VkResult", "DestroyDescriptorPool",
+ Proto("void", "DestroyDescriptorPool",
[Param("VkDevice", "device"),
Param("VkDescriptorPool", "descriptorPool")]),
@@ -644,7 +644,7 @@
Param("uint32_t", "count"),
Param("const VkDescriptorSet*", "pDescriptorSets")]),
- Proto("VkResult", "UpdateDescriptorSets",
+ Proto("void", "UpdateDescriptorSets",
[Param("VkDevice", "device"),
Param("uint32_t", "writeCount"),
Param("const VkWriteDescriptorSet*", "pDescriptorWrites"),
@@ -656,7 +656,7 @@
Param("const VkDynamicViewportStateCreateInfo*", "pCreateInfo"),
Param("VkDynamicViewportState*", "pState")]),
- Proto("VkResult", "DestroyDynamicViewportState",
+ Proto("void", "DestroyDynamicViewportState",
[Param("VkDevice", "device"),
Param("VkDynamicViewportState", "dynamicViewportState")]),
@@ -665,7 +665,7 @@
Param("const VkDynamicLineWidthStateCreateInfo*", "pCreateInfo"),
Param("VkDynamicLineWidthState*", "pState")]),
- Proto("VkResult", "DestroyDynamicLineWidthState",
+ Proto("void", "DestroyDynamicLineWidthState",
[Param("VkDevice", "device"),
Param("VkDynamicLineWidthState", "dynamicLineWidthState")]),
@@ -674,7 +674,7 @@
Param("const VkDynamicDepthBiasStateCreateInfo*", "pCreateInfo"),
Param("VkDynamicDepthBiasState*", "pState")]),
- Proto("VkResult", "DestroyDynamicDepthBiasState",
+ Proto("void", "DestroyDynamicDepthBiasState",
[Param("VkDevice", "device"),
Param("VkDynamicDepthBiasState", "dynamicDepthBiasState")]),
@@ -683,7 +683,7 @@
Param("const VkDynamicBlendStateCreateInfo*", "pCreateInfo"),
Param("VkDynamicBlendState*", "pState")]),
- Proto("VkResult", "DestroyDynamicBlendState",
+ Proto("void", "DestroyDynamicBlendState",
[Param("VkDevice", "device"),
Param("VkDynamicBlendState", "DynamicBlendState")]),
@@ -692,7 +692,7 @@
Param("const VkDynamicDepthBoundsStateCreateInfo*", "pCreateInfo"),
Param("VkDynamicDepthBoundsState*", "pState")]),
- Proto("VkResult", "DestroyDynamicDepthBoundsState",
+ Proto("void", "DestroyDynamicDepthBoundsState",
[Param("VkDevice", "device"),
Param("VkDynamicDepthBoundsState", "dynamicDepthBoundsState")]),
@@ -702,7 +702,7 @@
Param("const VkDynamicStencilStateCreateInfo*", "pCreateInfoBack"),
Param("VkDynamicStencilState*", "pState")]),
- Proto("VkResult", "DestroyDynamicStencilState",
+ Proto("void", "DestroyDynamicStencilState",
[Param("VkDevice", "device"),
Param("VkDynamicStencilState", "dynamicStencilState")]),
@@ -711,7 +711,7 @@
Param("const VkCmdPoolCreateInfo*", "pCreateInfo"),
Param("VkCmdPool*", "pCmdPool")]),
- Proto("VkResult", "DestroyCommandPool",
+ Proto("void", "DestroyCommandPool",
[Param("VkDevice", "device"),
Param("VkCmdPool", "cmdPool")]),
@@ -725,7 +725,7 @@
Param("const VkCmdBufferCreateInfo*", "pCreateInfo"),
Param("VkCmdBuffer*", "pCmdBuffer")]),
- Proto("VkResult", "DestroyCommandBuffer",
+ Proto("void", "DestroyCommandBuffer",
[Param("VkDevice", "device"),
Param("VkCmdBuffer", "commandBuffer")]),
@@ -996,7 +996,7 @@
Param("const VkFramebufferCreateInfo*", "pCreateInfo"),
Param("VkFramebuffer*", "pFramebuffer")]),
- Proto("VkResult", "DestroyFramebuffer",
+ Proto("void", "DestroyFramebuffer",
[Param("VkDevice", "device"),
Param("VkFramebuffer", "framebuffer")]),
@@ -1005,7 +1005,7 @@
Param("const VkRenderPassCreateInfo*", "pCreateInfo"),
Param("VkRenderPass*", "pRenderPass")]),
- Proto("VkResult", "DestroyRenderPass",
+ Proto("void", "DestroyRenderPass",
[Param("VkDevice", "device"),
Param("VkRenderPass", "renderPass")]),