aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorCourtney Goeltzenleuchter <courtney@LunarG.com>2015-10-20 16:40:38 -0600
committerCourtney Goeltzenleuchter <courtney@LunarG.com>2015-10-23 17:31:14 -0600
commitbd5c174bb264d5581719d8666b0646dbc83315ae (patch)
tree8b85347616573ab4899024725a03859cdaa6bb63
parentaf7f549a72cdf48ba7a438dce80f063819e0c093 (diff)
downloadusermoji-bd5c174bb264d5581719d8666b0646dbc83315ae.tar.xz
Bug 14621: Change vkGet* functions to not return VkResult
Diffstat
-rw-r--r--demos/cube.c34
-rw-r--r--demos/tri.c30
-rw-r--r--demos/vulkaninfo.c28
-rw-r--r--icd/nulldrv/nulldrv.c54
-rw-r--r--include/vulkan.h56
-rw-r--r--layers/basic.cpp5
-rw-r--r--layers/device_limits.cpp49
-rw-r--r--layers/image.cpp21
-rw-r--r--layers/mem_tracker.cpp33
-rw-r--r--layers/multi.cpp12
-rw-r--r--layers/object_track.h17
-rw-r--r--layers/param_checker.cpp250
-rw-r--r--layers/screenshot.cpp32
-rw-r--r--loader/loader.c49
-rw-r--r--loader/loader.h14
-rw-r--r--loader/trampoline.c75
-rwxr-xr-xvulkan.py28
17 files changed, 254 insertions, 533 deletions
diff --git a/demos/cube.c b/demos/cube.c
index 394a2d6c..aed2b931 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -873,7 +873,7 @@ static void demo_prepare_depth(struct demo *demo)
&demo->depth.image);
assert(!err);
- err = vkGetImageMemoryRequirements(demo->device,
+ vkGetImageMemoryRequirements(demo->device,
demo->depth.image, &mem_reqs);
assert(!err);
@@ -993,8 +993,7 @@ static void demo_prepare_texture_image(struct demo *demo,
&tex_obj->image);
assert(!err);
- err = vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
- assert(!err);
+ vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
tex_obj->mem_alloc.pNext = NULL;
@@ -1023,8 +1022,7 @@ static void demo_prepare_texture_image(struct demo *demo,
VkSubresourceLayout layout;
void *data;
- err = vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
- assert(!err);
+ vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
assert(!err);
@@ -1055,13 +1053,12 @@ static void demo_prepare_textures(struct demo *demo)
{
const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
VkFormatProperties props;
- VkResult U_ASSERT_ONLY err;
uint32_t i;
- err = vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
- assert(!err);
+ vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
+ VkResult U_ASSERT_ONLY err;
if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
/* Device can texture using linear textures */
@@ -1193,8 +1190,7 @@ void demo_prepare_cube_data_buffer(struct demo *demo)
err = vkCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf);
assert(!err);
- err = vkGetBufferMemoryRequirements(demo->device, demo->uniform_data.buf, &mem_reqs);
- assert(!err);
+ vkGetBufferMemoryRequirements(demo->device, demo->uniform_data.buf, &mem_reqs);
demo->uniform_data.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
demo->uniform_data.mem_alloc.pNext = NULL;
@@ -2272,17 +2268,14 @@ static void demo_init_vk(struct demo *demo)
break;
}
}
- err = vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
- assert(!err);
+ vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
/* Call with NULL data to get count */
- err = vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
- assert(!err);
+ vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
assert(demo->queue_count >= 1);
demo->queue_props = (VkQueueFamilyProperties *) malloc(demo->queue_count * sizeof(VkQueueFamilyProperties));
- err = vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
- assert(!err);
+ vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
// Find a queue that supports gfx
uint32_t gfx_queue_idx = 0;
for (gfx_queue_idx = 0; gfx_queue_idx<demo->queue_count; gfx_queue_idx++) {
@@ -2293,8 +2286,7 @@ static void demo_init_vk(struct demo *demo)
// Query fine-grained feature support for this device.
// If app has specific feature requirements it should check supported features based on this query
VkPhysicalDeviceFeatures physDevFeatures;
- err = vkGetPhysicalDeviceFeatures(demo->gpu, &physDevFeatures);
- assert(!err);
+ vkGetPhysicalDeviceFeatures(demo->gpu, &physDevFeatures);
const VkDeviceQueueCreateInfo queue = {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
@@ -2405,9 +2397,8 @@ static void demo_init_vk_swapchain(struct demo *demo)
demo->graphics_queue_node_index = graphicsQueueNodeIndex;
- err = vkGetDeviceQueue(demo->device, demo->graphics_queue_node_index,
+ vkGetDeviceQueue(demo->device, demo->graphics_queue_node_index,
0, &demo->queue);
- assert(!err);
// Get the list of VkFormat's that are supported:
uint32_t formatCount;
@@ -2439,8 +2430,7 @@ static void demo_init_vk_swapchain(struct demo *demo)
demo->curFrame = 0;
// Get Memory information and properties
- err = vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
- assert(!err);
+ vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
}
static void demo_init_connection(struct demo *demo)
diff --git a/demos/tri.c b/demos/tri.c
index dc450f8a..9b276e91 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -687,7 +687,7 @@ static void demo_prepare_depth(struct demo *demo)
assert(!err);
/* get memory requirements for this object */
- err = vkGetImageMemoryRequirements(demo->device, demo->depth.image,
+ vkGetImageMemoryRequirements(demo->device, demo->depth.image,
&mem_reqs);
/* select memory size and type */
@@ -759,8 +759,7 @@ static void demo_prepare_texture_image(struct demo *demo,
&tex_obj->image);
assert(!err);
- err = vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
- assert(!err);
+ vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
mem_alloc.allocationSize = mem_reqs.size;
err = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, required_props, &mem_alloc.memoryTypeIndex);
@@ -785,8 +784,7 @@ static void demo_prepare_texture_image(struct demo *demo,
void *data;
int32_t x, y;
- err = vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
- assert(!err);
+ vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
err = vkMapMemory(demo->device, tex_obj->mem, 0, mem_alloc.allocationSize, 0, &data);
assert(!err);
@@ -822,11 +820,10 @@ static void demo_prepare_textures(struct demo *demo)
const uint32_t tex_colors[DEMO_TEXTURE_COUNT][2] = {
{ 0xffff0000, 0xff00ff00 },
};
- VkResult U_ASSERT_ONLY err;
uint32_t i;
+ VkResult err;
- err = vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
- assert(!err);
+ vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
@@ -955,7 +952,7 @@ static void demo_prepare_vertices(struct demo *demo)
err = vkCreateBuffer(demo->device, &buf_info, &demo->vertices.buf);
assert(!err);
- err = vkGetBufferMemoryRequirements(demo->device,
+ vkGetBufferMemoryRequirements(demo->device,
demo->vertices.buf, &mem_reqs);
assert(!err);
@@ -1944,16 +1941,13 @@ static void demo_init_vk(struct demo *demo)
GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageKHR);
GET_DEVICE_PROC_ADDR(demo->device, QueuePresentKHR);
- err = vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
- assert(!err);
+ vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
// Query with NULL data to get count
- err = vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
- assert(!err);
+ vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
demo->queue_props = (VkQueueFamilyProperties *) malloc(demo->queue_count * sizeof(VkQueueFamilyProperties));
- err = vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
- assert(!err);
+ vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
assert(demo->queue_count >= 1);
// Graphics queue and MemMgr queue can be separate.
@@ -2035,9 +2029,8 @@ static void demo_init_vk_swapchain(struct demo *demo)
demo->graphics_queue_node_index = graphicsQueueNodeIndex;
- err = vkGetDeviceQueue(demo->device, demo->graphics_queue_node_index,
+ vkGetDeviceQueue(demo->device, demo->graphics_queue_node_index,
0, &demo->queue);
- assert(!err);
// Get the list of VkFormat's that are supported:
uint32_t formatCount;
@@ -2066,8 +2059,7 @@ static void demo_init_vk_swapchain(struct demo *demo)
demo->color_space = surfFormats[0].colorSpace;
// Get Memory information and properties
- err = vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
- assert(!err);
+ vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
}
static void demo_init_connection(struct demo *demo)
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index c8d091d0..5453c488 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -345,13 +345,8 @@ static void app_dev_init_formats(struct app_dev *dev)
for (f = 0; f < VK_FORMAT_NUM; f++) {
const VkFormat fmt = f;
- VkResult err;
- err = vkGetPhysicalDeviceFormatProperties(dev->gpu->obj, fmt, &dev->format_props[f]);
- if (err) {
- memset(&dev->format_props[f], 0,
- sizeof(dev->format_props[f]));
- }
+ vkGetPhysicalDeviceFormatProperties(dev->gpu->obj, fmt, &dev->format_props[f]);
}
}
@@ -637,7 +632,6 @@ static void app_destroy_instance(struct app_instance *inst)
static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VkPhysicalDevice obj)
{
- VkResult err;
uint32_t i;
memset(gpu, 0, sizeof(*gpu));
@@ -645,23 +639,17 @@ static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VkPhysicalDevice obj)
gpu->id = id;
gpu->obj = obj;
- err = vkGetPhysicalDeviceProperties(gpu->obj, &gpu->props);
- if (err)
- ERR_EXIT(err);
+ vkGetPhysicalDeviceProperties(gpu->obj, &gpu->props);
/* get queue count */
- err = vkGetPhysicalDeviceQueueFamilyProperties(gpu->obj, &gpu->queue_count, NULL);
- if (err)
- ERR_EXIT(err);
+ vkGetPhysicalDeviceQueueFamilyProperties(gpu->obj, &gpu->queue_count, NULL);
gpu->queue_props =
malloc(sizeof(gpu->queue_props[0]) * gpu->queue_count);
if (!gpu->queue_props)
ERR_EXIT(VK_ERROR_OUT_OF_HOST_MEMORY);
- err = vkGetPhysicalDeviceQueueFamilyProperties(gpu->obj, &gpu->queue_count, gpu->queue_props);
- if (err)
- ERR_EXIT(err);
+ vkGetPhysicalDeviceQueueFamilyProperties(gpu->obj, &gpu->queue_count, gpu->queue_props);
/* set up queue requests */
gpu->queue_reqs = malloc(sizeof(*gpu->queue_reqs) * gpu->queue_count);
@@ -674,13 +662,9 @@ static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VkPhysicalDevice obj)
gpu->queue_reqs[i].queueCount = gpu->queue_props[i].queueCount;
}
- err = vkGetPhysicalDeviceMemoryProperties(gpu->obj, &gpu->memory_props);
- if (err)
- ERR_EXIT(err);
+ vkGetPhysicalDeviceMemoryProperties(gpu->obj, &gpu->memory_props);
- err = vkGetPhysicalDeviceFeatures(gpu->obj, &gpu->features);
- if (err)
- ERR_EXIT(err);
+ vkGetPhysicalDeviceFeatures(gpu->obj, &gpu->features);
app_dev_init(&gpu->dev, gpu);
app_dev_init_formats(&gpu->dev);
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 8dc8dc43..2f082472 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1239,7 +1239,7 @@ ICD_EXPORT void VKAPI vkDestroyDevice(
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT VkResult VKAPI vkGetDeviceQueue(
+ICD_EXPORT void VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueNodeIndex,
uint32_t queueIndex,
@@ -1248,7 +1248,6 @@ ICD_EXPORT VkResult VKAPI vkGetDeviceQueue(
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
*pQueue = (VkQueue) dev->queues[0];
- return VK_SUCCESS;
}
ICD_EXPORT VkResult VKAPI vkDeviceWaitIdle(
@@ -1345,12 +1344,11 @@ ICD_EXPORT VkResult VKAPI vkWaitForFences(
return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
+ICD_EXPORT void VKAPI vkGetPhysicalDeviceProperties(
VkPhysicalDevice gpu_,
VkPhysicalDeviceProperties* pProperties)
{
NULLDRV_LOG_FUNC;
- VkResult ret = VK_SUCCESS;
pProperties->apiVersion = VK_API_VERSION;
pProperties->driverVersion = 0; // Appropriate that the nulldrv have 0's
@@ -1362,59 +1360,49 @@ ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
/* TODO: fill out limits */
memset(&pProperties->limits, 0, sizeof(VkPhysicalDeviceLimits));
memset(&pProperties->sparseProperties, 0, sizeof(VkPhysicalDeviceSparseProperties));
- return ret;
}
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(
+ICD_EXPORT void VKAPI vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures)
{
NULLDRV_LOG_FUNC;
- VkResult ret = VK_SUCCESS;
/* TODO: fill out features */
memset(pFeatures, 0, sizeof(*pFeatures));
-
- return ret;
}
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
+ICD_EXPORT void VKAPI vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatInfo)
{
NULLDRV_LOG_FUNC;
- VkResult ret = VK_SUCCESS;
pFormatInfo->linearTilingFeatures = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
pFormatInfo->optimalTilingFeatures = pFormatInfo->linearTilingFeatures;
pFormatInfo->bufferFeatures = 0;
-
- return ret;
}
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
+ICD_EXPORT void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice gpu_,
uint32_t* pCount,
VkQueueFamilyProperties* pProperties)
{
if (pProperties == NULL) {
*pCount = 1;
- return VK_SUCCESS;
+ return;
}
pProperties->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_SPARSE_MEMMGR_BIT;
pProperties->queueCount = 1;
pProperties->timestampValidBits = 0;
-
- return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+ICD_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice gpu_,
VkPhysicalDeviceMemoryProperties* pProperties)
{
// TODO: Fill in with real data
- return VK_SUCCESS;
}
ICD_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
@@ -1485,7 +1473,7 @@ ICD_EXPORT void VKAPI vkDestroyImage(
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(
+ICD_EXPORT void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
@@ -1497,8 +1485,6 @@ ICD_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(
pLayout->size = 1;
pLayout->rowPitch = 4;
pLayout->depthPitch = 4;
-
- return VK_SUCCESS;
}
ICD_EXPORT VkResult VKAPI vkAllocMemory(
@@ -1561,12 +1547,11 @@ ICD_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(
return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkGetDeviceMemoryCommitment(
+ICD_EXPORT void VKAPI vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes)
{
- return VK_SUCCESS;
}
ICD_EXPORT VkResult VKAPI vkCreateInstance(
@@ -1620,7 +1605,7 @@ ICD_EXPORT VkResult VKAPI vkEnumerateLayers(
return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkGetBufferMemoryRequirements(
+ICD_EXPORT void VKAPI vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements)
@@ -1628,10 +1613,10 @@ ICD_EXPORT VkResult VKAPI vkGetBufferMemoryRequirements(
NULLDRV_LOG_FUNC;
struct nulldrv_base *base = nulldrv_base((void*)buffer.handle);
- return base->get_memory_requirements(base, pMemoryRequirements);
+ base->get_memory_requirements(base, pMemoryRequirements);
}
-ICD_EXPORT VkResult VKAPI vkGetImageMemoryRequirements(
+ICD_EXPORT void VKAPI vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements)
@@ -1639,7 +1624,7 @@ ICD_EXPORT VkResult VKAPI vkGetImageMemoryRequirements(
NULLDRV_LOG_FUNC;
struct nulldrv_base *base = nulldrv_base((void*)image.handle);
- return base->get_memory_requirements(base, pMemoryRequirements);
+ base->get_memory_requirements(base, pMemoryRequirements);
}
ICD_EXPORT VkResult VKAPI vkBindBufferMemory(
@@ -1662,17 +1647,16 @@ ICD_EXPORT VkResult VKAPI vkBindImageMemory(
return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(
+ICD_EXPORT void VKAPI vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pNumRequirements,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
NULLDRV_LOG_FUNC;
- return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+ICD_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -1683,7 +1667,6 @@ ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
VkSparseImageFormatProperties* pProperties)
{
NULLDRV_LOG_FUNC;
- return VK_SUCCESS;
}
ICD_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
@@ -2128,15 +2111,13 @@ ICD_EXPORT void VKAPI vkCmdPushConstants(
/* TODO: Implement */
}
-ICD_EXPORT VkResult VKAPI vkGetRenderAreaGranularity(
+ICD_EXPORT void VKAPI vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity)
{
pGranularity->height = 1;
pGranularity->width = 1;
-
- return VK_SUCCESS;
}
ICD_EXPORT void VKAPI vkCmdBeginRenderPass(
@@ -2194,7 +2175,7 @@ ICD_EXPORT VkResult xcbQueuePresent(void *queue, void *image, void* fence)
return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+ICD_EXPORT void VKAPI vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -2203,5 +2184,4 @@ ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties)
{
- return VK_ERROR_INITIALIZATION_FAILED;
}
diff --git a/include/vulkan.h b/include/vulkan.h
index 5fd2b056..18140bc2 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -2100,12 +2100,12 @@ typedef struct {
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_vkEnumerateInstanceExtensionProperties)(const char*
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 VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, V
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 VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBuffer
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 VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFrame
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 @@ VkResult VKAPI vkEnumeratePhysicalDevices(
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 @@ VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
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 @@ VkResult VKAPI vkEnumerateDeviceLayerProperties(
uint32_t* pCount,
VkLayerProperties* pProperties);
-VkResult VKAPI vkGetDeviceQueue(
+void VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
@@ -2371,7 +2371,7 @@ VkResult VKAPI vkInvalidateMappedMemoryRanges(
uint32_t memRangeCount,
const VkMappedMemoryRange* pMemRanges);
-VkResult VKAPI vkGetDeviceMemoryCommitment(
+void VKAPI vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes);
@@ -2388,23 +2388,23 @@ VkResult VKAPI vkBindImageMemory(
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 @@ void VKAPI vkDestroyImage(
VkDevice device,
VkImage image);
-VkResult VKAPI vkGetImageSubresourceLayout(
+void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
@@ -2695,7 +2695,7 @@ void VKAPI vkDestroyRenderPass(
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 b90c0755..778a3629 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -119,12 +119,11 @@ VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance)
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 1c3018b1..eded3573 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -244,36 +244,31 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(VkInstance instance, u
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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysic
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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysic
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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer c
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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueF
"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 52800bfa..736c44a3 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -280,12 +280,8 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat
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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
{
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 void VKAPI vkCmdResolveImage(
}
}
-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 5ca81848..4a1e85f6 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1071,17 +1071,13 @@ VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
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 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
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 @@ VkResult VKAPI vkBindImageMemory(
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 47b1ba5b..1db6b6f2 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -118,28 +118,24 @@ VK_LAYER_EXPORT VkResult VKAPI multi2EnumeratePhysicalDevices(
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 dea26642..99ad2ea2 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -655,19 +655,18 @@ explicit_CreateInstance(
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 @@ VkResult explicit_EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysi
return result;
}
-VkResult
+void
explicit_GetDeviceQueue(
VkDevice device,
uint32_t queueNodeIndex,
@@ -725,16 +724,12 @@ explicit_GetDeviceQueue(
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 4595325c..de4890a0 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1919,40 +1919,29 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
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 @@ bool PostGetPhysicalDeviceFormatProperties(
{
}
- 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);
-
- PostGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties, result);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
- return result;
+ PostGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
}
bool PostGetPhysicalDeviceImageFormatProperties(
@@ -1996,8 +1976,7 @@ bool PostGetPhysicalDeviceImageFormatProperties(
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
- VkImageFormatProperties* pImageFormatProperties,
- VkResult result)
+ VkImageFormatProperties* pImageFormatProperties)
{
if(format < VK_FORMAT_BEGIN_RANGE ||
@@ -2029,17 +2008,10 @@ bool PostGetPhysicalDeviceImageFormatProperties(
{
}
- 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties)
{
- VkResult result = 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);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
- 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 @@ bool PostGetPhysicalDeviceProperties(
}
}
- 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 @@ bool PostGetPhysicalDeviceQueueFamilyProperties(
{
}
- 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueProperties(
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);
-
- PostGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties, result);
+ get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
- return result;
+ PostGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
@@ -2204,8 +2144,7 @@ bool PostGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
- VkQueue* pQueue,
- VkResult result)
+ VkQueue* pQueue)
{
@@ -2214,27 +2153,18 @@ bool PostGetDeviceQueue(
{
}
- 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);
-
- PostGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, result);
+ get_dispatch_table(pc_device_table_map, device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
- return result;
+ PostGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
}
bool PreQueueSubmit(
@@ -2525,8 +2455,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(
bool PostGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes,
- VkResult result)
+ VkDeviceSize* pCommittedMemoryInBytes)
{
@@ -2534,26 +2463,17 @@ bool PostGetDeviceMemoryCommitment(
{
}
- 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkBindImageMemory(
bool PostGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements,
- VkResult result)
+ VkMemoryRequirements* pMemoryRequirements)
{
@@ -2636,33 +2555,23 @@ bool PostGetBufferMemoryRequirements(
{
}
- 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 @@ bool PostGetImageMemoryRequirements(
{
}
- 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 @@ bool PostGetImageSparseMemoryRequirements(
}
}
- 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);
-
- PostGetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements, result);
+ get_dispatch_table(pc_device_table_map, device)->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
- return result;
+ PostGetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
}
bool PostGetPhysicalDeviceSparseImageFormatProperties(
@@ -2747,8 +2637,7 @@ bool PostGetPhysicalDeviceSparseImageFormatProperties(
VkImageUsageFlags usage,
VkImageTiling tiling,
uint32_t* pNumProperties,
- VkSparseImageFormatProperties* pProperties,
- VkResult result)
+ VkSparseImageFormatProperties* pProperties)
{
if(format < VK_FORMAT_BEGIN_RANGE ||
@@ -2792,17 +2681,10 @@ bool PostGetPhysicalDeviceSparseImageFormatProperties(
}
}
- 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
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 PreGetImageSubresourceLayout(
bool PostGetImageSubresourceLayout(
VkDevice device,
VkImage image,
- VkSubresourceLayout* pLayout,
- VkResult result)
+ VkSubresourceLayout* pLayout)
{
@@ -3710,17 +3589,10 @@ bool PostGetImageSubresourceLayout(
{
}
- 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(
{
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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
bool PostGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
- VkExtent2D* pGranularity,
- VkResult result)
+ VkExtent2D* pGranularity)
{
@@ -5227,26 +5096,17 @@ bool PostGetRenderAreaGranularity(
{
}
- 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 ac3e20d7..c468257a 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -210,13 +210,11 @@ static void writePPM( const char *filename, VkImage image1)
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 @@ static void writePPM( const char *filename, VkImage image1)
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 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
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 22a80b15..cac71a6f 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -2808,79 +2808,64 @@ VkResult VKAPI loader_EnumeratePhysicalDevices(
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 @@ VkResult VKAPI loader_GetPhysicalDeviceImageFormatProperties(
{
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 @@ VkResult VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
{
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 890821ca..3e4ce1bf 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -275,16 +275,16 @@ VkResult VKAPI loader_EnumeratePhysicalDevices(
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 @@ VkResult VKAPI loader_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties);
-VkResult VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
+void VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -302,7 +302,7 @@ VkResult VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
uint32_t* pNumProperties,
VkSparseImageFormatProperties* pProperties);
-VkResult VKAPI loader_GetPhysicalDeviceProperties (
+void VKAPI loader_GetPhysicalDeviceProperties (
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties);
@@ -314,12 +314,12 @@ VkResult VKAPI loader_EnumerateDeviceLayerProperties (VkPhysicalDevice physicalD
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 b2c00c1d..cbf8a861 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -214,76 +214,64 @@ LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
-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 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
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 @@ LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uin
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 @@ LOADER_EXPORT VkResult VKAPI vkBindImageMemory(VkDevice device, VkImage image, V
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 @@ LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
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 @@ LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass rende
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/vulkan.py b/vulkan.py
index c58416a9..6bc70b28 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -223,16 +223,16 @@ core = Extension(
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 @@ core = Extension(
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 @@ core = Extension(
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 @@ core = Extension(
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 @@ core = Extension(
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 @@ core = Extension(
[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 @@ core = Extension(
[Param("VkDevice", "device"),
Param("VkRenderPass", "renderPass")]),
- Proto("VkResult", "GetRenderAreaGranularity",
+ Proto("void", "GetRenderAreaGranularity",
[Param("VkDevice", "device"),
Param("VkRenderPass", "renderPass"),
Param("VkExtent2D*", "pGranularity")]),
generated by cgit v1.2.3 (git 2.39.1) at 2026-09-02 06:54:23 +0000