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/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(