Bug 14621: Change vkGet* functions to not return VkResult
diff --git a/include/vulkan.h b/include/vulkan.h
index 5fd2b05..18140bc 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -2100,12 +2100,12 @@
typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
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);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
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);
@@ -2114,7 +2114,7 @@
typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
@@ -2124,13 +2124,13 @@
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);
+typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
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);
@@ -2157,7 +2157,7 @@
typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
-typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+typedef void (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 void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
@@ -2188,7 +2188,7 @@
typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
-typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
@@ -2255,16 +2255,16 @@
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices);
-VkResult VKAPI vkGetPhysicalDeviceFeatures(
+void VKAPI vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures);
-VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
+void VKAPI vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties);
-VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+void VKAPI vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -2273,16 +2273,16 @@
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties);
-VkResult VKAPI vkGetPhysicalDeviceProperties(
+void VKAPI vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties);
-VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
+void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkQueueFamilyProperties* pQueueFamilyProperties);
-VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+void VKAPI vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties);
@@ -2322,7 +2322,7 @@
uint32_t* pCount,
VkLayerProperties* pProperties);
-VkResult VKAPI vkGetDeviceQueue(
+void VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
@@ -2371,7 +2371,7 @@
uint32_t memRangeCount,
const VkMappedMemoryRange* pMemRanges);
-VkResult VKAPI vkGetDeviceMemoryCommitment(
+void VKAPI vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes);
@@ -2388,23 +2388,23 @@
VkDeviceMemory mem,
VkDeviceSize memOffset);
-VkResult VKAPI vkGetBufferMemoryRequirements(
+void VKAPI vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements);
-VkResult VKAPI vkGetImageMemoryRequirements(
+void VKAPI vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements);
-VkResult VKAPI vkGetImageSparseMemoryRequirements(
+void VKAPI vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pNumRequirements,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -2540,7 +2540,7 @@
VkDevice device,
VkImage image);
-VkResult VKAPI vkGetImageSubresourceLayout(
+void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
@@ -2695,7 +2695,7 @@
VkDevice device,
VkRenderPass renderPass);
-VkResult VKAPI vkGetRenderAreaGranularity(
+void VKAPI vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity);
diff --git a/layers/basic.cpp b/layers/basic.cpp
index b90c075..778a362 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -119,12 +119,11 @@
destroy_instance_dispatch_table(key);
}
-VK_LAYER_EXPORT VkResult VKAPI basic_GetPhysicalDeviceFormatProperties(VkPhysicalDevice gpu, VkFormat format, VkFormatProperties *pFormatInfo)
+VK_LAYER_EXPORT void VKAPI basic_GetPhysicalDeviceFormatProperties(VkPhysicalDevice gpu, VkFormat format, VkFormatProperties *pFormatInfo)
{
printf("At start of wrapped vkGetPhysicalDeviceFormatProperties() call w/ gpu: %p\n", (void*)gpu);
- VkResult result = instance_dispatch_table(gpu)->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
+ instance_dispatch_table(gpu)->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
printf("Completed wrapped vkGetPhysicalDeviceFormatProperties() call w/ gpu: %p\n", (void*)gpu);
- return result;
}
VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index 1c3018b..eded357 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -244,36 +244,31 @@
return VK_ERROR_VALIDATION_FAILED;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
{
layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
phy_dev_data->physicalDeviceState->vkGetPhysicalDeviceFeaturesState = QUERY_DETAILS;
- VkResult result = phy_dev_data->instance_dispatch_table->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
- return result;
+ phy_dev_data->instance_dispatch_table->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
{
- VkResult result = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceFormatProperties(
- physicalDevice, format, pFormatProperties);
- return result;
+ get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceFormatProperties(
+ physicalDevice, format, pFormatProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
{
- VkResult result = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
- return result;
+ get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
{
layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
- VkResult result = phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, pProperties);
-
- return result;
+ phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, pProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties)
{
VkBool32 skipCall = VK_FALSE;
layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
@@ -294,8 +289,8 @@
phy_dev_data->physicalDeviceState->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_DETAILS;
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
- VkResult result = phy_dev_data->instance_dispatch_table->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
+ return;
+ phy_dev_data->instance_dispatch_table->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
if (NULL == pQueueFamilyProperties) {
phy_dev_data->physicalDeviceState->queueFamilyPropertiesCount = *pCount;
} else { // Save queue family properties
@@ -304,24 +299,21 @@
phy_dev_data->queueFamilyProperties.emplace_back(new VkQueueFamilyProperties(pQueueFamilyProperties[i]));
}
}
- return result;
+ return;
} else {
log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_PHYSICAL_DEVICE, "DL",
"Invalid physicalDevice (%#" PRIxLEAST64 ") passed into vkGetPhysicalDeviceQueueFamilyProperties().", physicalDevice);
}
- return VK_ERROR_VALIDATION_FAILED;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
- VkResult result = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
- return result;
+ get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties)
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties)
{
- VkResult result = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
- return result;
+ get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
@@ -477,7 +469,7 @@
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandBuffer(device, commandBuffer);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+VK_LAYER_EXPORT void VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
{
VkBool32 skipCall = VK_FALSE;
layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -491,9 +483,8 @@
"Invalid queue request in vkGetDeviceQueue(). QueueFamilyIndex %u only has %u queues, but requested queueIndex is %u.", queueFamilyIndex, phy_dev_data->queueFamilyProperties[queueFamilyIndex]->queueCount, queueIndex);
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
- VkResult result = dev_data->device_dispatch_table->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
- return result;
+ return;
+ dev_data->device_dispatch_table->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
diff --git a/layers/image.cpp b/layers/image.cpp
index 52800bf..736c44a 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -280,12 +280,8 @@
if(pCreateInfo->format != VK_FORMAT_UNDEFINED)
{
VkFormatProperties properties;
- VkResult result = get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatProperties(
+ get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatProperties(
device_data->physicalDevice, pCreateInfo->format, &properties);
- if(result != VK_SUCCESS) {
- char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, cannot be validated";
- skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", str);
- }
if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
{
@@ -320,15 +316,8 @@
{
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkFormatProperties properties;
- VkResult result = get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatProperties(
+ get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatProperties(
device_data->physicalDevice, pCreateInfo->pAttachments[i].format, &properties);
- if(result != VK_SUCCESS)
- {
- std::stringstream ss;
- ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], cannot be validated";
- skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", ss.str().c_str());
- continue;
- }
if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
{
@@ -725,19 +714,17 @@
}
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(
+VK_LAYER_EXPORT void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource *pSubresource,
VkSubresourceLayout *pLayout)
{
- VkResult result = get_dispatch_table(image_device_table_map, device)->GetImageSubresourceLayout(device,
+ get_dispatch_table(image_device_table_map, device)->GetImageSubresourceLayout(device,
image, pSubresource, pLayout);
// TODO: After state tracking for images/buffers is implemented, validate that returned aspects match
// the created formats -- color for color formats, depth|stencil for ds formats
-
- return result;
}
VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 5ca8184..4a1e85f 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1071,17 +1071,13 @@
assert(mem_tracker_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties *pMemoryProperties)
{
VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(mem_tracker_instance_table_map, physicalDevice);
- VkResult result = pInstanceTable->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
- if (result == VK_SUCCESS) {
- // copy mem props to local var...
- memcpy(&memProps, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties));
- }
- return result;
+ pInstanceTable->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+ memcpy(&memProps, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties));
}
static const VkLayerProperties mtGlobalLayers[] = {
@@ -1131,19 +1127,16 @@
pCount, pProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(
+VK_LAYER_EXPORT void VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueNodeIndex,
uint32_t queueIndex,
VkQueue *pQueue)
{
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
- if (result == VK_SUCCESS) {
- loader_platform_thread_lock_mutex(&globalLock);
- add_queue_info(*pQueue);
- loader_platform_thread_unlock_mutex(&globalLock);
- }
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ loader_platform_thread_lock_mutex(&globalLock);
+ add_queue_info(*pQueue);
+ loader_platform_thread_unlock_mutex(&globalLock);
}
VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
@@ -1321,26 +1314,24 @@
return result;
}
-VkResult VKAPI vkGetBufferMemoryRequirements(
+void VKAPI vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements)
{
// TODO : What to track here?
// Could potentially save returned mem requirements and validate values passed into BindBufferMemory
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
}
-VkResult VKAPI vkGetImageMemoryRequirements(
+void VKAPI vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements)
{
// TODO : What to track here?
// Could potentially save returned mem requirements and validate values passed into BindImageMemory
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
- return result;
+ get_dispatch_table(mem_tracker_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
}
VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 47b1ba5..1db6b6f 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -118,28 +118,24 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI multi2GetPhysicalDeviceProperties(
+VK_LAYER_EXPORT void VKAPI multi2GetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties)
{
VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(multi2_instance_table_map, physicalDevice);
printf("At start of wrapped multi2 vkGetPhysicalDeviceProperties()\n");
- VkResult result = pDisp->GetPhysicalDeviceProperties(physicalDevice, pProperties);
+ pDisp->GetPhysicalDeviceProperties(physicalDevice, pProperties);
printf("Completed multi2 layer vkGetPhysicalDeviceProperties()\n");
-
- return result;
}
-VK_LAYER_EXPORT VkResult VKAPI multi2GetPhysicalDeviceFeatures(
+VK_LAYER_EXPORT void VKAPI multi2GetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures)
{
VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(multi2_instance_table_map, physicalDevice);
printf("At start of wrapped multi2 vkGetPhysicalDeviceFeatures()\n");
- VkResult result = pDisp->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+ pDisp->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
printf("Completed multi2 layer vkGetPhysicalDeviceFeatures()\n");
-
- return result;
}
/* hook DestroyInstance to remove tableInstanceMap entry */
diff --git a/layers/object_track.h b/layers/object_track.h
index dea2664..99ad2ea 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -655,19 +655,18 @@
return result;
}
-VkResult
+void
explicit_GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice gpu,
uint32_t* pCount,
VkQueueFamilyProperties* pProperties)
{
- VkResult result = get_dispatch_table(ObjectTracker_instance_table_map, gpu)->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pProperties);
+ get_dispatch_table(ObjectTracker_instance_table_map, gpu)->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pProperties);
loader_platform_thread_lock_mutex(&objLock);
if (pProperties != NULL)
setGpuQueueInfoState(*pCount, pProperties);
loader_platform_thread_unlock_mutex(&objLock);
- return result;
}
VkResult
@@ -714,7 +713,7 @@
return result;
}
-VkResult
+void
explicit_GetDeviceQueue(
VkDevice device,
uint32_t queueNodeIndex,
@@ -725,16 +724,12 @@
validate_object(device, device);
loader_platform_thread_unlock_mutex(&objLock);
- VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ get_dispatch_table(ObjectTracker_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
loader_platform_thread_lock_mutex(&objLock);
- if (VK_SUCCESS == result) {
- addQueueInfo(queueNodeIndex, *pQueue);
- create_obj(device, *pQueue, VK_OBJECT_TYPE_QUEUE);
- }
+ addQueueInfo(queueNodeIndex, *pQueue);
+ create_obj(device, *pQueue, VK_OBJECT_TYPE_QUEUE);
loader_platform_thread_unlock_mutex(&objLock);
-
- return result;
}
VkResult
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 4595325..de4890a 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1919,40 +1919,29 @@
bool PostGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures,
- VkResult result)
+ VkPhysicalDeviceFeatures* pFeatures)
{
if(pFeatures != nullptr)
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetPhysicalDeviceFeatures parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures)
{
- VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
- PostGetPhysicalDeviceFeatures(physicalDevice, pFeatures, result);
-
- return result;
+ PostGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
}
bool PostGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
- VkFormatProperties* pFormatProperties,
- VkResult result)
+ VkFormatProperties* pFormatProperties)
{
if(format < VK_FORMAT_BEGIN_RANGE ||
@@ -1967,26 +1956,17 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetPhysicalDeviceFormatProperties parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties)
{
- VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
- PostGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties, result);
-
- return result;
+ PostGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
}
bool PostGetPhysicalDeviceImageFormatProperties(
@@ -1996,8 +1976,7 @@
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
- VkImageFormatProperties* pImageFormatProperties,
- VkResult result)
+ VkImageFormatProperties* pImageFormatProperties)
{
if(format < VK_FORMAT_BEGIN_RANGE ||
@@ -2029,17 +2008,10 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetPhysicalDeviceImageFormatProperties parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -2048,17 +2020,14 @@
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties)
{
- VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
- PostGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, result);
-
- return result;
+ PostGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
}
bool PostGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties,
- VkResult result)
+ VkPhysicalDeviceProperties* pProperties)
{
if(pProperties != nullptr)
@@ -2072,32 +2041,22 @@
}
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetPhysicalDeviceProperties parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties)
{
- VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties);
- PostGetPhysicalDeviceProperties(physicalDevice, pProperties, result);
-
- return result;
+ PostGetPhysicalDeviceProperties(physicalDevice, pProperties);
}
bool PostGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
- VkQueueFamilyProperties* pQueueProperties,
- VkResult result)
+ VkQueueFamilyProperties* pQueueProperties)
{
if(pQueueProperties == nullptr && pCount != nullptr)
@@ -2108,13 +2067,6 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetPhysicalDeviceQueueFamilyProperties parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
return true;
}
@@ -2123,42 +2075,30 @@
uint32_t* pCount,
VkQueueFamilyProperties* pQueueProperties)
{
- VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueProperties);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueProperties);
- PostGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueProperties, result);
-
- return result;
+ PostGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueProperties);
}
bool PostGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties* pMemoryProperties,
- VkResult result)
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
if(pMemoryProperties != nullptr)
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetPhysicalDeviceMemoryProperties parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
- VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
- PostGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties, result);
-
- return result;
+ PostGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
@@ -2204,8 +2144,7 @@
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
- VkQueue* pQueue,
- VkResult result)
+ VkQueue* pQueue)
{
@@ -2214,27 +2153,18 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetDeviceQueue 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 vkGetDeviceQueue(
+VK_LAYER_EXPORT void VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
VkQueue* pQueue)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+ get_dispatch_table(pc_device_table_map, device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
- PostGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, result);
-
- return result;
+ PostGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
}
bool PreQueueSubmit(
@@ -2525,8 +2455,7 @@
bool PostGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes,
- VkResult result)
+ VkDeviceSize* pCommittedMemoryInBytes)
{
@@ -2534,26 +2463,17 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetDeviceMemoryCommitment 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 vkGetDeviceMemoryCommitment(
+VK_LAYER_EXPORT void VKAPI vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+ get_dispatch_table(pc_device_table_map, device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
- PostGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes, result);
-
- return result;
+ PostGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
}
bool PostBindBufferMemory(
@@ -2627,8 +2547,7 @@
bool PostGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements,
- VkResult result)
+ VkMemoryRequirements* pMemoryRequirements)
{
@@ -2636,33 +2555,23 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetBufferMemoryRequirements 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 vkGetBufferMemoryRequirements(
+VK_LAYER_EXPORT void VKAPI vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+ get_dispatch_table(pc_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
- PostGetBufferMemoryRequirements(device, buffer, pMemoryRequirements, result);
-
- return result;
+ PostGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
}
bool PostGetImageMemoryRequirements(
VkDevice device,
VkImage image,
- VkMemoryRequirements* pMemoryRequirements,
- VkResult result)
+ VkMemoryRequirements* pMemoryRequirements)
{
@@ -2670,34 +2579,24 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetImageMemoryRequirements 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 vkGetImageMemoryRequirements(
+VK_LAYER_EXPORT void VKAPI vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
+ get_dispatch_table(pc_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
- PostGetImageMemoryRequirements(device, image, pMemoryRequirements, result);
-
- return result;
+ PostGetImageMemoryRequirements(device, image, pMemoryRequirements);
}
bool PostGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pNumRequirements,
- VkSparseImageMemoryRequirements* pSparseMemoryRequirements,
- VkResult result)
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
@@ -2716,27 +2615,18 @@
}
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetImageSparseMemoryRequirements 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 vkGetImageSparseMemoryRequirements(
+VK_LAYER_EXPORT void VKAPI vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pNumRequirements,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+ get_dispatch_table(pc_device_table_map, device)->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
- PostGetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements, result);
-
- return result;
+ PostGetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
}
bool PostGetPhysicalDeviceSparseImageFormatProperties(
@@ -2747,8 +2637,7 @@
VkImageUsageFlags usage,
VkImageTiling tiling,
uint32_t* pNumProperties,
- VkSparseImageFormatProperties* pProperties,
- VkResult result)
+ VkSparseImageFormatProperties* pProperties)
{
if(format < VK_FORMAT_BEGIN_RANGE ||
@@ -2792,17 +2681,10 @@
}
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
- return false;
- }
-
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+VK_LAYER_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -2812,11 +2694,9 @@
uint32_t* pNumProperties,
VkSparseImageFormatProperties* pProperties)
{
- VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
- PostGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties, result);
-
- return result;
+ PostGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
}
bool PreQueueBindSparseBufferMemory(
@@ -3701,8 +3581,7 @@
bool PostGetImageSubresourceLayout(
VkDevice device,
VkImage image,
- VkSubresourceLayout* pLayout,
- VkResult result)
+ VkSubresourceLayout* pLayout)
{
@@ -3710,17 +3589,10 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetImageSubresourceLayout 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 vkGetImageSubresourceLayout(
+VK_LAYER_EXPORT void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
@@ -3728,11 +3600,9 @@
{
PreGetImageSubresourceLayout(device, pSubresource);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+ get_dispatch_table(pc_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
- PostGetImageSubresourceLayout(device, image, pLayout, result);
-
- return result;
+ PostGetImageSubresourceLayout(device, image, pLayout);
}
bool PreCreateImageView(
@@ -5218,8 +5088,7 @@
bool PostGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
- VkExtent2D* pGranularity,
- VkResult result)
+ VkExtent2D* pGranularity)
{
@@ -5227,26 +5096,17 @@
{
}
- if(result < VK_SUCCESS)
- {
- std::string reason = "vkGetRenderAreaGranularity 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 vkGetRenderAreaGranularity(
+VK_LAYER_EXPORT void VKAPI vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->GetRenderAreaGranularity(device, renderPass, pGranularity);
+ get_dispatch_table(pc_device_table_map, device)->GetRenderAreaGranularity(device, renderPass, pGranularity);
- PostGetRenderAreaGranularity(device, renderPass, pGranularity, result);
-
- return result;
+ PostGetRenderAreaGranularity(device, renderPass, pGranularity);
}
bool PreCreateCommandPool(
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index ac3e20d..c468257 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -210,13 +210,11 @@
err = pTableDevice->CreateImage(device, &imgCreateInfo, &image2);
assert(!err);
- err = pTableDevice->GetImageMemoryRequirements(device, image2, &memRequirements);
- assert(!err);
+ pTableDevice->GetImageMemoryRequirements(device, image2, &memRequirements);
memAllocInfo.allocationSize = memRequirements.size;
pInstanceTable = instance_dispatch_table(instance);
- err = pInstanceTable->GetPhysicalDeviceMemoryProperties(physicalDevice, &memory_properties);
- assert(!err);
+ pInstanceTable->GetPhysicalDeviceMemoryProperties(physicalDevice, &memory_properties);
err = memory_type_from_properties(&memory_properties,
memRequirements.memoryTypeBits,
@@ -255,8 +253,7 @@
err = pTableDevice->DeviceWaitIdle(device);
assert(!err);
- err = pTableDevice->GetImageSubresourceLayout(device, image2, &sr, &sr_layout);
- assert(!err);
+ pTableDevice->GetImageSubresourceLayout(device, image2, &sr, &sr_layout);
err = pTableDevice->MapMemory(device, mem2, 0, 0, 0, (void **) &ptr );
assert(!err);
@@ -422,35 +419,32 @@
pCount, pProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(
+VK_LAYER_EXPORT void VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueNodeIndex,
uint32_t queueIndex,
VkQueue *pQueue)
{
VkLayerDispatchTable* pTable = screenshot_device_table_map[device];
- VkResult result = get_dispatch_table(screenshot_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ get_dispatch_table(screenshot_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
loader_platform_thread_lock_mutex(&globalLock);
if (screenshotEnvQueried && screenshotFrames.empty()) {
// We are all done taking screenshots, so don't do anything else
loader_platform_thread_unlock_mutex(&globalLock);
- return result;
+ return;
}
- if (result == VK_SUCCESS) {
- screenshot_device_table_map.emplace(*pQueue, pTable);
+ screenshot_device_table_map.emplace(*pQueue, pTable);
- // Create a mapping from a device to a queue
- if (deviceMap[device] == NULL)
- {
- DeviceMapStruct *deviceMapElem = new DeviceMapStruct;
- deviceMap[device] = deviceMapElem;
- }
- deviceMap[device]->queue = *pQueue;
+ // Create a mapping from a device to a queue
+ if (deviceMap[device] == NULL)
+ {
+ DeviceMapStruct *deviceMapElem = new DeviceMapStruct;
+ deviceMap[device] = deviceMapElem;
}
+ deviceMap[device]->queue = *pQueue;
loader_platform_thread_unlock_mutex(&globalLock);
- return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
diff --git a/loader/loader.c b/loader/loader.c
index 22a80b1..cac71a6 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -2808,79 +2808,64 @@
return VK_SUCCESS;
}
-VkResult VKAPI loader_GetPhysicalDeviceProperties(
+void VKAPI loader_GetPhysicalDeviceProperties(
VkPhysicalDevice gpu,
VkPhysicalDeviceProperties* pProperties)
{
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
- VkResult res = VK_ERROR_INITIALIZATION_FAILED;
if (icd->GetPhysicalDeviceProperties)
- res = icd->GetPhysicalDeviceProperties(gpu, pProperties);
-
- return res;
+ icd->GetPhysicalDeviceProperties(gpu, pProperties);
}
-VkResult VKAPI loader_GetPhysicalDeviceQueueFamilyProperties (
+void VKAPI loader_GetPhysicalDeviceQueueFamilyProperties (
VkPhysicalDevice gpu,
uint32_t* pCount,
VkQueueFamilyProperties* pProperties)
{
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
- VkResult res = VK_ERROR_INITIALIZATION_FAILED;
if (icd->GetPhysicalDeviceQueueFamilyProperties)
- res = icd->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pProperties);
-
- return res;
+ icd->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pProperties);
}
-VkResult VKAPI loader_GetPhysicalDeviceMemoryProperties (
+void VKAPI loader_GetPhysicalDeviceMemoryProperties (
VkPhysicalDevice gpu,
VkPhysicalDeviceMemoryProperties* pProperties)
{
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
- VkResult res = VK_ERROR_INITIALIZATION_FAILED;
if (icd->GetPhysicalDeviceMemoryProperties)
- res = icd->GetPhysicalDeviceMemoryProperties(gpu, pProperties);
-
- return res;
+ icd->GetPhysicalDeviceMemoryProperties(gpu, pProperties);
}
-VkResult VKAPI loader_GetPhysicalDeviceFeatures(
+void VKAPI loader_GetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures)
{
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
- VkResult res = VK_ERROR_INITIALIZATION_FAILED;
if (icd->GetPhysicalDeviceFeatures)
- res = icd->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-
- return res;
+ icd->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
}
-VkResult VKAPI loader_GetPhysicalDeviceFormatProperties(
+void VKAPI loader_GetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatInfo)
{
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
- VkResult res = VK_ERROR_INITIALIZATION_FAILED;
if (icd->GetPhysicalDeviceFormatProperties)
- res = icd->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatInfo);
-
- return res;
+ icd->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatInfo);
}
-VkResult VKAPI loader_GetPhysicalDeviceImageFormatProperties(
+void VKAPI loader_GetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -2891,16 +2876,13 @@
{
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
- VkResult res = VK_ERROR_INITIALIZATION_FAILED;
if (icd->GetPhysicalDeviceImageFormatProperties)
- res = icd->GetPhysicalDeviceImageFormatProperties(physicalDevice, format,
+ icd->GetPhysicalDeviceImageFormatProperties(physicalDevice, format,
type, tiling, usage, flags, pImageFormatProperties);
-
- return res;
}
-VkResult VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
+void VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -2912,12 +2894,9 @@
{
uint32_t gpu_index;
struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
- VkResult res = VK_ERROR_INITIALIZATION_FAILED;
if (icd->GetPhysicalDeviceSparseImageFormatProperties)
- res = icd->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
-
- return res;
+ icd->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
}
VkResult VKAPI loader_CreateDevice(
diff --git a/loader/loader.h b/loader/loader.h
index 890821c..3e4ce1b 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -275,16 +275,16 @@
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices);
-VkResult VKAPI loader_GetPhysicalDeviceFeatures(
+void VKAPI loader_GetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures);
-VkResult VKAPI loader_GetPhysicalDeviceFormatProperties(
+void VKAPI loader_GetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatInfo);
-VkResult VKAPI loader_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,
+void VKAPI loader_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
@@ -292,7 +292,7 @@
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties);
-VkResult VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
+void VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -302,7 +302,7 @@
uint32_t* pNumProperties,
VkSparseImageFormatProperties* pProperties);
-VkResult VKAPI loader_GetPhysicalDeviceProperties (
+void VKAPI loader_GetPhysicalDeviceProperties (
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties);
@@ -314,12 +314,12 @@
uint32_t *pCount,
VkLayerProperties* pProperties);
-VkResult VKAPI loader_GetPhysicalDeviceQueueFamilyProperties (
+void VKAPI loader_GetPhysicalDeviceQueueFamilyProperties (
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkQueueFamilyProperties* pProperties);
-VkResult VKAPI loader_GetPhysicalDeviceMemoryProperties (
+void VKAPI loader_GetPhysicalDeviceMemoryProperties (
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties * pProperties);
diff --git a/loader/trampoline.c b/loader/trampoline.c
index b2c00c1..cbf8a86 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -214,76 +214,64 @@
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceFeatures(
VkPhysicalDevice gpu,
VkPhysicalDeviceFeatures *pFeatures)
{
const VkLayerInstanceDispatchTable *disp;
- VkResult res;
disp = loader_get_instance_dispatch(gpu);
- res = disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
- return res;
+ disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
}
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice gpu,
VkFormat format,
VkFormatProperties *pFormatInfo)
{
const VkLayerInstanceDispatchTable *disp;
- VkResult res;
disp = loader_get_instance_dispatch(gpu);
- res = disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
- return res;
+ disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
}
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
{
const VkLayerInstanceDispatchTable *disp;
- VkResult res;
disp = loader_get_instance_dispatch(physicalDevice);
- res = disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
- return res;
+ disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
}
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceProperties(
VkPhysicalDevice gpu,
VkPhysicalDeviceProperties* pProperties)
{
const VkLayerInstanceDispatchTable *disp;
- VkResult res;
disp = loader_get_instance_dispatch(gpu);
- res = disp->GetPhysicalDeviceProperties(gpu, pProperties);
- return res;
+ disp->GetPhysicalDeviceProperties(gpu, pProperties);
}
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice gpu,
uint32_t* pCount,
VkQueueFamilyProperties* pQueueProperties)
{
const VkLayerInstanceDispatchTable *disp;
- VkResult res;
disp = loader_get_instance_dispatch(gpu);
- res = disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pQueueProperties);
- return res;
+ disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pQueueProperties);
}
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice gpu,
VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
const VkLayerInstanceDispatchTable *disp;
- VkResult res;
disp = loader_get_instance_dispatch(gpu);
- res = disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
- return res;
+ disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
}
LOADER_EXPORT VkResult VKAPI vkCreateDevice(
@@ -344,19 +332,14 @@
return res;
}
-LOADER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue)
+LOADER_EXPORT void VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue)
{
const VkLayerDispatchTable *disp;
- VkResult res;
disp = loader_get_dispatch(device);
- res = disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
- if (res == VK_SUCCESS) {
- loader_set_dispatch(*pQueue, disp);
- }
-
- return res;
+ disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ loader_set_dispatch(*pQueue, disp);
}
LOADER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence)
@@ -440,13 +423,13 @@
return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
}
-LOADER_EXPORT VkResult VKAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+LOADER_EXPORT void VKAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+ disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
}
LOADER_EXPORT VkResult VKAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset)
@@ -467,40 +450,40 @@
return disp->BindImageMemory(device, image, mem, offset);
}
-LOADER_EXPORT VkResult VKAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+LOADER_EXPORT void VKAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+ disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
}
-LOADER_EXPORT VkResult VKAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+LOADER_EXPORT void VKAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
+ disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
}
-LOADER_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+LOADER_EXPORT void VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+ disp->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
}
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties)
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties)
{
const VkLayerInstanceDispatchTable *disp;
disp = loader_get_instance_dispatch(physicalDevice);
- return disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+ disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
}
LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
@@ -737,13 +720,13 @@
disp->DestroyImage(device, image);
}
-LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+LOADER_EXPORT void VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+ disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
}
LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
@@ -1018,13 +1001,13 @@
disp->DestroyRenderPass(device, renderPass);
}
-LOADER_EXPORT VkResult VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+LOADER_EXPORT void VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
+ disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
}
LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index b6acdb9..8fbf83a 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -1275,10 +1275,8 @@
it != test_formats_.end(); it++) {
const float color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
VkFormatProperties props;
- VkResult err;
- err = vkGetPhysicalDeviceFormatProperties(dev_.phy().handle(), it->format, &props);
- ASSERT_EQ(err, VK_SUCCESS);
+ vkGetPhysicalDeviceFormatProperties(dev_.phy().handle(), it->format, &props);
if (it->tiling == VK_IMAGE_TILING_LINEAR && !(props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
continue;
@@ -1453,10 +1451,8 @@
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
VkFormatProperties props;
- VkResult err;
- err = vkGetPhysicalDeviceFormatProperties(dev_.phy().handle(), it->format, &props);
- ASSERT_EQ(err, VK_SUCCESS);
+ vkGetPhysicalDeviceFormatProperties(dev_.phy().handle(), it->format, &props);
if (it->tiling == VK_IMAGE_TILING_LINEAR && !(props.linearTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
continue;
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 2d7ff5f..885a0b6 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -150,8 +150,7 @@
* amount of data may vary and that doesn't work well for using a
* fixed structure.
*/
- err = vkGetPhysicalDeviceFormatProperties(this->objs[0], fmt, &image_fmt);
- ASSERT_VK_SUCCESS(err);
+ vkGetPhysicalDeviceFormatProperties(this->objs[0], fmt, &image_fmt);
// typedef struct VkImageCreateInfo_
// {
@@ -221,8 +220,7 @@
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.pNext = NULL;
- err = vkGetImageMemoryRequirements(device(), m_image, &mem_req);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(device(), m_image, &mem_req);
ASSERT_NE(0, mem_req.size) << "vkGetObjectMemoryRequirements (Image): Failed - expect images to require memory";
mem_info.allocationSize = mem_req.size;
diff --git a/tests/init.cpp b/tests/init.cpp
index 0c058ea..70aa900 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -272,14 +272,12 @@
void getQueue(vk_testing::Device *device, uint32_t queue_node_index, const char *qname)
{
uint32_t que_idx;
- VkResult err;
VkQueue queue;
const VkQueueFamilyProperties props = device->phy().queue_properties()[queue_node_index];
for (que_idx = 0; que_idx < props.queueCount; que_idx++) {
// TODO: Need to add support for separate MEMMGR and work queues, including synchronization
- err = vkGetDeviceQueue(device->handle(), queue_node_index, que_idx, &queue);
- ASSERT_EQ(VK_SUCCESS, err) << "vkGetDeviceQueue: " << qname << " queue #" << que_idx << ": Failed with error: " << vk_result_string(err);
+ vkGetDeviceQueue(device->handle(), queue_node_index, que_idx, &queue);
}
}
@@ -315,8 +313,7 @@
* fixed structure.
*/
- err = vkGetPhysicalDeviceFormatProperties(objs[m_device_id], fmt, &image_fmt);
- ASSERT_VK_SUCCESS(err);
+ vkGetPhysicalDeviceFormatProperties(objs[m_device_id], fmt, &image_fmt);
// typedef struct VkImageCreateInfo_
// {
@@ -364,7 +361,7 @@
ASSERT_VK_SUCCESS(err);
// Verify image resources
-// VkResult VKAPI vkGetImageSubresourceLayout(
+// void VKAPI vkGetImageSubresourceLayout(
// VkImage image,
// const VkImageSubresource* pSubresource,
// VkSubresourceLayout* pLayout);
@@ -394,8 +391,7 @@
while ((_w > 0) || (_h > 0))
{
VkSubresourceLayout layout = {};
- err = vkGetImageSubresourceLayout(device(), image, &subresource, &layout);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageSubresourceLayout(device(), image, &subresource, &layout);
// TODO: 4 should be replaced with pixel size for given format
EXPECT_LE(_w * 4, layout.rowPitch) << "Pitch does not match expected image pitch";
@@ -409,8 +405,7 @@
VkMemoryRequirements mem_req;
VkDeviceMemory image_mem;
- err = vkGetImageMemoryRequirements(device(), image, &mem_req);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(device(), image, &mem_req);
if (mem_req.size) {
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 9d1d081..68037f3 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -515,10 +515,9 @@
err = vkCreateImage(m_device->device(), &image_create_info, &image);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(),
+ vkGetImageMemoryRequirements(m_device->device(),
image,
&mem_reqs);
- ASSERT_VK_SUCCESS(err);
mem_alloc.allocationSize = mem_reqs.size;
@@ -665,10 +664,9 @@
err = vkCreateImage(m_device->device(), &image_create_info, &image);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(),
+ vkGetImageMemoryRequirements(m_device->device(),
image,
&mem_reqs);
- ASSERT_VK_SUCCESS(err);
mem_alloc.allocationSize = mem_reqs.size;
err = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
@@ -922,10 +920,9 @@
err = vkCreateImage(m_device->device(), &image_create_info, &image);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(),
+ vkGetImageMemoryRequirements(m_device->device(),
image,
&mem_reqs);
- ASSERT_VK_SUCCESS(err);
mem_alloc.allocationSize = mem_reqs.size;
@@ -995,10 +992,9 @@
err = vkCreateImage(m_device->device(), &image_create_info, &image);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(),
+ vkGetImageMemoryRequirements(m_device->device(),
image,
&mem_reqs);
- ASSERT_VK_SUCCESS(err);
mem_alloc.allocationSize = mem_reqs.size;
err = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0);
@@ -4369,16 +4365,14 @@
memAlloc.allocationSize = 0;
memAlloc.memoryTypeIndex = 0;
- err = vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
@@ -4476,16 +4470,14 @@
memAlloc.allocationSize = 0;
memAlloc.memoryTypeIndex = 0;
- err = vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
@@ -4578,16 +4570,14 @@
memAlloc.allocationSize = 0;
memAlloc.memoryTypeIndex = 0;
- err = vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
@@ -4683,16 +4673,14 @@
memAlloc.allocationSize = 0;
memAlloc.memoryTypeIndex = 0;
- err = vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
@@ -4789,16 +4777,14 @@
memAlloc.allocationSize = 0;
memAlloc.memoryTypeIndex = 0;
- err = vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
@@ -4895,16 +4881,14 @@
memAlloc.allocationSize = 0;
memAlloc.memoryTypeIndex = 0;
- err = vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
ASSERT_VK_SUCCESS(err);
- err = vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
- ASSERT_VK_SUCCESS(err);
+ vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
err = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index e0b44e4..5c8cc6d 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -312,10 +312,8 @@
VkImageObj *img = new VkImageObj(m_device);
VkFormatProperties props;
- VkResult err;
- err = vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), m_render_target_fmt, &props);
- ASSERT_VK_SUCCESS(err);
+ vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), m_render_target_fmt, &props);
if (props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
img->init((uint32_t)m_width, (uint32_t)m_height, m_render_target_fmt,
@@ -691,7 +689,6 @@
uint32_t mipCount;
VkFormatProperties image_fmt;
VkImageTiling tiling;
- VkResult err;
mipCount = 0;
@@ -704,8 +701,7 @@
mipCount++;
}
- err = vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), fmt, &image_fmt);
- ASSERT_VK_SUCCESS(err);
+ vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), fmt, &image_fmt);
if (requested_tiling == VK_IMAGE_TILING_LINEAR) {
if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 1942592..dfe81a0 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -91,7 +91,7 @@
{
VkPhysicalDeviceProperties info;
- EXPECT(vkGetPhysicalDeviceProperties(handle(), &info) == VK_SUCCESS);
+ vkGetPhysicalDeviceProperties(handle(), &info);
return info;
}
@@ -102,11 +102,9 @@
uint32_t count;
// Call once with NULL data to receive count
- if (EXPECT(vkGetPhysicalDeviceQueueFamilyProperties(handle(), &count, NULL) == VK_SUCCESS)) {
- info.resize(count);
- if (!EXPECT(vkGetPhysicalDeviceQueueFamilyProperties(handle(), &count, info.data()) == VK_SUCCESS))
- info.clear();
- }
+ vkGetPhysicalDeviceQueueFamilyProperties(handle(), &count, NULL);
+ info.resize(count);
+ vkGetPhysicalDeviceQueueFamilyProperties(handle(), &count, info.data());
return info;
}
@@ -115,8 +113,7 @@
{
VkPhysicalDeviceMemoryProperties info;
- EXPECT(vkGetPhysicalDeviceMemoryProperties(handle(), &info) == VK_SUCCESS);
-
+ vkGetPhysicalDeviceMemoryProperties(handle(), &info);
return info;
}
@@ -310,26 +307,22 @@
void Device::init_queues()
{
- VkResult err;
uint32_t queue_node_count;
// Call with NULL data to get count
- err = vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, NULL);
- EXPECT(err == VK_SUCCESS);
+ vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, NULL);
EXPECT(queue_node_count >= 1);
VkQueueFamilyProperties* queue_props = new VkQueueFamilyProperties[queue_node_count];
- err = vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, queue_props);
- EXPECT(err == VK_SUCCESS);
+ vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, queue_props);
for (uint32_t i = 0; i < queue_node_count; i++) {
VkQueue queue;
for (uint32_t j = 0; j < queue_props[i].queueCount; j++) {
// TODO: Need to add support for separate MEMMGR and work queues, including synchronization
- err = vkGetDeviceQueue(handle(), i, j, &queue);
- EXPECT(err == VK_SUCCESS);
+ vkGetDeviceQueue(handle(), i, j, &queue);
if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
queues_[GRAPHICS].push_back(new Queue(queue, i));
@@ -373,10 +366,7 @@
VkFormatProperties Device::format_properties(VkFormat format)
{
VkFormatProperties data;
- VkResult res = vkGetPhysicalDeviceFormatProperties(phy().handle(), format, &data);
- if (res != VK_SUCCESS)
- memset(&data, 0, sizeof(data));
- EXPECT(res == VK_SUCCESS || res == VK_UNSUPPORTED);
+ vkGetPhysicalDeviceFormatProperties(phy().handle(), format, &data);
return data;
}
@@ -538,7 +528,7 @@
{
VkMemoryRequirements reqs;
- EXPECT(vkGetBufferMemoryRequirements(device(), handle(), &reqs) == VK_SUCCESS);
+ vkGetBufferMemoryRequirements(device(), handle(), &reqs);
return reqs;
}
@@ -587,7 +577,7 @@
{
VkMemoryRequirements reqs;
- EXPECT(vkGetImageMemoryRequirements(device(), handle(), &reqs) == VK_SUCCESS);
+ vkGetImageMemoryRequirements(device(), handle(), &reqs);
return reqs;
}
@@ -601,7 +591,8 @@
{
VkSubresourceLayout data;
size_t size = sizeof(data);
- if (!EXPECT(vkGetImageSubresourceLayout(device(), handle(), &subres, &data) == VK_SUCCESS && size == sizeof(data)))
+ vkGetImageSubresourceLayout(device(), handle(), &subres, &data);
+ if (size != sizeof(data))
memset(&data, 0, sizeof(data));
return data;
@@ -612,7 +603,8 @@
VkSubresourceLayout data;
VkImageSubresource subres = subresource(subrescopy.aspect, subrescopy.mipLevel, subrescopy.arrayLayer);
size_t size = sizeof(data);
- if (!EXPECT(vkGetImageSubresourceLayout(device(), handle(), &subres, &data) == VK_SUCCESS && size == sizeof(data)))
+ vkGetImageSubresourceLayout(device(), handle(), &subres, &data);
+ if (size != sizeof(data))
memset(&data, 0, sizeof(data));
return data;
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index c07d48f..cc39646 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -304,7 +304,6 @@
void VkTestFramework::WritePPM( const char *basename, VkImageObj *image )
{
string filename;
- VkResult err;
uint32_t x, y;
VkImageObj displayImage(image->device());
VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
@@ -320,8 +319,7 @@
};
VkSubresourceLayout sr_layout;
- err = vkGetImageSubresourceLayout(image->device()->device(), displayImage.image(), &sr, &sr_layout);
- ASSERT_VK_SUCCESS( err );
+ vkGetImageSubresourceLayout(image->device()->device(), displayImage.image(), &sr, &sr_layout);
char *ptr;
ptr = (char *) displayImage.MapMemory();
@@ -435,8 +433,7 @@
VK_IMAGE_ASPECT_COLOR, 0, 0
};
- err = vkGetImageSubresourceLayout(displayImage.device()->device(), displayImage.image(), &sr, &sr_layout);
- ASSERT_VK_SUCCESS( err );
+ vkGetImageSubresourceLayout(displayImage.device()->device(), displayImage.image(), &sr, &sr_layout);
ptr = (char *) displayImage.MapMemory();
ASSERT_VK_SUCCESS( err );
diff --git a/vulkan.py b/vulkan.py
index c58416a..6bc70b2 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -223,16 +223,16 @@
Param("uint32_t*", "pPhysicalDeviceCount"),
Param("VkPhysicalDevice*", "pPhysicalDevices")]),
- Proto("VkResult", "GetPhysicalDeviceFeatures",
+ Proto("void", "GetPhysicalDeviceFeatures",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("VkPhysicalDeviceFeatures*", "pFeatures")]),
- Proto("VkResult", "GetPhysicalDeviceFormatProperties",
+ Proto("void", "GetPhysicalDeviceFormatProperties",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("VkFormat", "format"),
Param("VkFormatProperties*", "pFormatProperties")]),
- Proto("VkResult", "GetPhysicalDeviceImageFormatProperties",
+ Proto("void", "GetPhysicalDeviceImageFormatProperties",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("VkFormat", "format"),
Param("VkImageType", "type"),
@@ -257,16 +257,16 @@
Proto("void", "DestroyDevice",
[Param("VkDevice", "device")]),
- Proto("VkResult", "GetPhysicalDeviceProperties",
+ Proto("void", "GetPhysicalDeviceProperties",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("VkPhysicalDeviceProperties*", "pProperties")]),
- Proto("VkResult", "GetPhysicalDeviceQueueFamilyProperties",
+ Proto("void", "GetPhysicalDeviceQueueFamilyProperties",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("uint32_t*", "pCount"),
Param("VkQueueFamilyProperties*", "pQueueFamilyProperties")]),
- Proto("VkResult", "GetPhysicalDeviceMemoryProperties",
+ Proto("void", "GetPhysicalDeviceMemoryProperties",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("VkPhysicalDeviceMemoryProperties*", "pMemoryProperties")]),
@@ -290,7 +290,7 @@
Param("uint32_t*", "pCount"),
Param("VkLayerProperties*", "pProperties")]),
- Proto("VkResult", "GetDeviceQueue",
+ Proto("void", "GetDeviceQueue",
[Param("VkDevice", "device"),
Param("uint32_t", "queueFamilyIndex"),
Param("uint32_t", "queueIndex"),
@@ -339,7 +339,7 @@
Param("uint32_t", "memRangeCount"),
Param("const VkMappedMemoryRange*", "pMemRanges")]),
- Proto("VkResult", "GetDeviceMemoryCommitment",
+ Proto("void", "GetDeviceMemoryCommitment",
[Param("VkDevice", "device"),
Param("VkDeviceMemory", "memory"),
Param("VkDeviceSize*", "pCommittedMemoryInBytes")]),
@@ -356,23 +356,23 @@
Param("VkDeviceMemory", "mem"),
Param("VkDeviceSize", "memOffset")]),
- Proto("VkResult", "GetBufferMemoryRequirements",
+ Proto("void", "GetBufferMemoryRequirements",
[Param("VkDevice", "device"),
Param("VkBuffer", "buffer"),
Param("VkMemoryRequirements*", "pMemoryRequirements")]),
- Proto("VkResult", "GetImageMemoryRequirements",
+ Proto("void", "GetImageMemoryRequirements",
[Param("VkDevice", "device"),
Param("VkImage", "image"),
Param("VkMemoryRequirements*", "pMemoryRequirements")]),
- Proto("VkResult", "GetImageSparseMemoryRequirements",
+ Proto("void", "GetImageSparseMemoryRequirements",
[Param("VkDevice", "device"),
Param("VkImage", "image"),
Param("uint32_t*", "pNumRequirements"),
Param("VkSparseImageMemoryRequirements*", "pSparseMemoryRequirements")]),
- Proto("VkResult", "GetPhysicalDeviceSparseImageFormatProperties",
+ Proto("void", "GetPhysicalDeviceSparseImageFormatProperties",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("VkFormat", "format"),
Param("VkImageType", "type"),
@@ -508,7 +508,7 @@
[Param("VkDevice", "device"),
Param("VkImage", "image")]),
- Proto("VkResult", "GetImageSubresourceLayout",
+ Proto("void", "GetImageSubresourceLayout",
[Param("VkDevice", "device"),
Param("VkImage", "image"),
Param("const VkImageSubresource*", "pSubresource"),
@@ -913,7 +913,7 @@
[Param("VkDevice", "device"),
Param("VkRenderPass", "renderPass")]),
- Proto("VkResult", "GetRenderAreaGranularity",
+ Proto("void", "GetRenderAreaGranularity",
[Param("VkDevice", "device"),
Param("VkRenderPass", "renderPass"),
Param("VkExtent2D*", "pGranularity")]),