bug 12921: Memory callback (WIP)
The per-object allocator is ignored for now.
https://cvs.khronos.org/bugzilla/show_bug.cgi?id=12921
diff --git a/demos/cube.c b/demos/cube.c
index 77a9410..2880cf9 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -637,6 +637,7 @@
err = vkCreateSemaphore(demo->device,
&presentCompleteSemaphoreCreateInfo,
+ NULL,
&presentCompleteSemaphore);
assert(!err);
@@ -650,7 +651,7 @@
// must be recreated:
demo_resize(demo);
demo_draw(demo);
- vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+ vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
return;
} else if (err == VK_SUBOPTIMAL_KHR) {
// demo->swapchain is not as optimal as it could be, but the platform's
@@ -711,7 +712,7 @@
err = vkQueueWaitIdle(demo->queue);
assert(err == VK_SUCCESS);
- vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+ vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
}
static void demo_prepare_buffers(struct demo *demo)
@@ -873,7 +874,7 @@
color_image_view.image = demo->buffers[i].image;
err = vkCreateImageView(demo->device,
- &color_image_view, &demo->buffers[i].view);
+ &color_image_view, NULL, &demo->buffers[i].view);
assert(!err);
}
}
@@ -918,7 +919,7 @@
demo->depth.format = depth_format;
/* create image */
- err = vkCreateImage(demo->device, &image,
+ err = vkCreateImage(demo->device, &image, NULL,
&demo->depth.image);
assert(!err);
@@ -938,7 +939,8 @@
assert(pass);
/* allocate memory */
- err = vkAllocMemory(demo->device, &demo->depth.mem_alloc, &demo->depth.mem);
+ err = vkAllocMemory(demo->device, &demo->depth.mem_alloc,
+ NULL, &demo->depth.mem);
assert(!err);
/* bind memory */
@@ -953,7 +955,7 @@
/* create image view */
view.image = demo->depth.image;
- err = vkCreateImageView(demo->device, &view, &demo->depth.view);
+ err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
assert(!err);
}
@@ -1047,7 +1049,7 @@
VkMemoryRequirements mem_reqs;
- err = vkCreateImage(demo->device, &image_create_info,
+ err = vkCreateImage(demo->device, &image_create_info, NULL,
&tex_obj->image);
assert(!err);
@@ -1062,7 +1064,7 @@
assert(pass);
/* allocate memory */
- err = vkAllocMemory(demo->device, &tex_obj->mem_alloc,
+ err = vkAllocMemory(demo->device, &tex_obj->mem_alloc, NULL,
&(tex_obj->mem));
assert(!err);
@@ -1103,8 +1105,8 @@
static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_objs)
{
/* clean up staging resources */
- vkFreeMemory(demo->device, tex_objs->mem);
- vkDestroyImage(demo->device, tex_objs->image);
+ vkFreeMemory(demo->device, tex_objs->mem, NULL);
+ vkDestroyImage(demo->device, tex_objs->image, NULL);
}
static void demo_prepare_textures(struct demo *demo)
@@ -1203,13 +1205,13 @@
};
/* create sampler */
- err = vkCreateSampler(demo->device, &sampler,
+ err = vkCreateSampler(demo->device, &sampler, NULL,
&demo->textures[i].sampler);
assert(!err);
/* create image view */
view.image = demo->textures[i].image;
- err = vkCreateImageView(demo->device, &view,
+ err = vkCreateImageView(demo->device, &view, NULL,
&demo->textures[i].view);
assert(!err);
}
@@ -1246,7 +1248,8 @@
buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
buf_info.size = sizeof(data);
- err = vkCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf);
+ err = vkCreateBuffer(demo->device, &buf_info, NULL,
+ &demo->uniform_data.buf);
assert(!err);
vkGetBufferMemoryRequirements(demo->device, demo->uniform_data.buf, &mem_reqs);
@@ -1262,7 +1265,8 @@
&demo->uniform_data.mem_alloc.memoryTypeIndex);
assert(pass);
- err = vkAllocMemory(demo->device, &demo->uniform_data.mem_alloc, &(demo->uniform_data.mem));
+ err = vkAllocMemory(demo->device, &demo->uniform_data.mem_alloc,
+ NULL, &(demo->uniform_data.mem));
assert(!err);
err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, demo->uniform_data.mem_alloc.allocationSize, 0, (void **) &pData);
@@ -1307,7 +1311,7 @@
VkResult U_ASSERT_ONLY err;
err = vkCreateDescriptorSetLayout(demo->device,
- &descriptor_layout, &demo->desc_layout);
+ &descriptor_layout, NULL, &demo->desc_layout);
assert(!err);
const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
@@ -1319,6 +1323,7 @@
err = vkCreatePipelineLayout(demo->device,
&pPipelineLayoutCreateInfo,
+ NULL,
&demo->pipeline_layout);
assert(!err);
}
@@ -1384,7 +1389,7 @@
};
VkResult U_ASSERT_ONLY err;
- err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
+ err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
assert(!err);
}
@@ -1411,14 +1416,14 @@
moduleCreateInfo.codeSize = size;
moduleCreateInfo.pCode = code;
moduleCreateInfo.flags = 0;
- err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+ err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
assert(!err);
shaderCreateInfo.flags = 0;
shaderCreateInfo.module = *pShaderModule;
shaderCreateInfo.pName = "main";
shaderCreateInfo.stage = stage;
- err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+ err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
assert(!err);
} else {
// Create fake SPV structure to feed GLSL
@@ -1433,7 +1438,7 @@
((uint32_t *) moduleCreateInfo.pCode)[2] = stage;
memcpy(((uint32_t *) moduleCreateInfo.pCode + 3), code, size + 1);
- err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+ err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
if (err) {
free((void *) moduleCreateInfo.pCode);
}
@@ -1442,7 +1447,7 @@
shaderCreateInfo.module = *pShaderModule;
shaderCreateInfo.pName = "main";
shaderCreateInfo.stage = stage;
- err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+ err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
assert(!err);
free((void *) moduleCreateInfo.pCode);
}
@@ -1635,7 +1640,7 @@
memset(&pipelineCache, 0, sizeof(pipelineCache));
pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
- err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache);
+ err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
assert(!err);
pipeline.pVertexInputState = &vi;
@@ -1651,14 +1656,15 @@
pipeline.renderPass = demo->render_pass;
- err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline);
+ err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache,
+ 1, &pipeline, NULL, &demo->pipeline);
assert(!err);
for (uint32_t i = 0; i < pipeline.stageCount; i++) {
- vkDestroyShader(demo->device, shaderStages[i].shader);
+ vkDestroyShader(demo->device, shaderStages[i].shader, NULL);
}
- vkDestroyShaderModule(demo->device, demo->frag_shader_module);
- vkDestroyShaderModule(demo->device, demo->vert_shader_module);
+ vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
+ vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
}
static void demo_prepare_descriptor_pool(struct demo *demo)
@@ -1683,7 +1689,7 @@
VkResult U_ASSERT_ONLY err;
err = vkCreateDescriptorPool(demo->device,
- &descriptor_pool, &demo->desc_pool);
+ &descriptor_pool, NULL, &demo->desc_pool);
assert(!err);
}
@@ -1752,7 +1758,7 @@
for (i = 0; i < demo->swapchainImageCount; i++) {
attachments[0] = demo->buffers[i].view;
- err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
+ err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->framebuffers[i]);
assert(!err);
}
}
@@ -1767,7 +1773,7 @@
.queueFamilyIndex = demo->graphics_queue_node_index,
.flags = 0,
};
- err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
+ err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
assert(!err);
const VkCmdBufferAllocInfo cmd = {
@@ -1819,46 +1825,46 @@
demo->prepared = false;
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+ vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
}
free(demo->framebuffers);
- vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+ vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
- vkDestroyPipeline(demo->device, demo->pipeline);
- vkDestroyPipelineCache(demo->device, demo->pipelineCache);
- vkDestroyRenderPass(demo->device, demo->render_pass);
- vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
- vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+ vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+ vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
+ vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+ vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
- vkDestroyImageView(demo->device, demo->textures[i].view);
- vkDestroyImage(demo->device, demo->textures[i].image);
- vkFreeMemory(demo->device, demo->textures[i].mem);
- vkDestroySampler(demo->device, demo->textures[i].sampler);
+ vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+ vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+ vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+ vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
}
demo->fpDestroySwapchainKHR(demo->device, demo->swapchain);
- vkDestroyImageView(demo->device, demo->depth.view);
- vkDestroyImage(demo->device, demo->depth.image);
- vkFreeMemory(demo->device, demo->depth.mem);
+ vkDestroyImageView(demo->device, demo->depth.view, NULL);
+ vkDestroyImage(demo->device, demo->depth.image, NULL);
+ vkFreeMemory(demo->device, demo->depth.mem, NULL);
- vkDestroyBuffer(demo->device, demo->uniform_data.buf);
- vkFreeMemory(demo->device, demo->uniform_data.mem);
+ vkDestroyBuffer(demo->device, demo->uniform_data.buf, NULL);
+ vkFreeMemory(demo->device, demo->uniform_data.mem, NULL);
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyImageView(demo->device, demo->buffers[i].view);
+ vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->buffers[i].cmd);
}
free(demo->buffers);
free(demo->queue_props);
- vkDestroyCommandPool(demo->device, demo->cmd_pool);
- vkDestroyDevice(demo->device);
+ vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
+ vkDestroyDevice(demo->device, NULL);
if (demo->validate) {
demo->dbgDestroyMsgCallback(demo->inst, demo->msg_callback);
}
- vkDestroyInstance(demo->inst);
+ vkDestroyInstance(demo->inst, NULL);
#ifndef _WIN32
xcb_destroy_window(demo->connection, demo->window);
@@ -1882,39 +1888,39 @@
demo->prepared = false;
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+ vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
}
free(demo->framebuffers);
- vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+ vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
- vkDestroyPipeline(demo->device, demo->pipeline);
- vkDestroyPipelineCache(demo->device, demo->pipelineCache);
- vkDestroyRenderPass(demo->device, demo->render_pass);
- vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
- vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+ vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+ vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
+ vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+ vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
- vkDestroyImageView(demo->device, demo->textures[i].view);
- vkDestroyImage(demo->device, demo->textures[i].image);
- vkFreeMemory(demo->device, demo->textures[i].mem);
- vkDestroySampler(demo->device, demo->textures[i].sampler);
+ vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+ vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+ vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+ vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
}
- vkDestroyImageView(demo->device, demo->depth.view);
- vkDestroyImage(demo->device, demo->depth.image);
- vkFreeMemory(demo->device, demo->depth.mem);
+ vkDestroyImageView(demo->device, demo->depth.view, NULL);
+ vkDestroyImage(demo->device, demo->depth.image, NULL);
+ vkFreeMemory(demo->device, demo->depth.mem, NULL);
- vkDestroyBuffer(demo->device, demo->uniform_data.buf);
- vkFreeMemory(demo->device, demo->uniform_data.mem);
+ vkDestroyBuffer(demo->device, demo->uniform_data.buf, NULL);
+ vkFreeMemory(demo->device, demo->uniform_data.mem, NULL);
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyImageView(demo->device, demo->buffers[i].view);
+ vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->buffers[i].cmd);
}
- vkDestroyCommandPool(demo->device, demo->cmd_pool);
+ vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
free(demo->buffers);
- vkDestroyCommandPool(demo->device, demo->cmd_pool);
+ vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
// Second, re-perform the demo_prepare() function, which will re-create the
@@ -2268,7 +2274,6 @@
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL,
.pAppInfo = &app,
- .pAllocCb = NULL,
.enabledLayerNameCount = enabled_layer_count,
.ppEnabledLayerNames = (const char *const*) ((demo->validate) ? instance_validation_layers : NULL),
.enabledExtensionNameCount = enabled_extension_count,
@@ -2277,7 +2282,7 @@
uint32_t gpu_count;
- err = vkCreateInstance(&inst_info, &demo->inst);
+ err = vkCreateInstance(&inst_info, NULL, &demo->inst);
if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
"(ICD).\n\nPlease look at the Getting Started guide for "
@@ -2444,7 +2449,7 @@
.pEnabledFeatures = NULL, // If specific features are required, pass them in here
};
- err = vkCreateDevice(demo->gpu, &device, &demo->device);
+ err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
assert(!err);
free(device_layers);
diff --git a/demos/tri.c b/demos/tri.c
index 83f99b7..bd4f8eb 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -169,6 +169,8 @@
bool use_staging_buffer;
bool use_glsl;
+ VkAllocCallbacks allocator;
+
VkInstance inst;
VkPhysicalDevice gpu;
VkDevice device;
@@ -454,6 +456,7 @@
err = vkCreateSemaphore(demo->device,
&presentCompleteSemaphoreCreateInfo,
+ NULL,
&presentCompleteSemaphore);
assert(!err);
@@ -467,7 +470,7 @@
// must be recreated:
demo_resize(demo);
demo_draw(demo);
- vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+ vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
return;
} else if (err == VK_SUBOPTIMAL_KHR) {
// demo->swapchain is not as optimal as it could be, but the platform's
@@ -531,7 +534,7 @@
err = vkQueueWaitIdle(demo->queue);
assert(err == VK_SUCCESS);
- vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+ vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
}
static void demo_prepare_buffers(struct demo *demo)
@@ -679,7 +682,7 @@
color_attachment_view.image = demo->buffers[i].image;
err = vkCreateImageView(demo->device,
- &color_attachment_view, &demo->buffers[i].view);
+ &color_attachment_view, NULL, &demo->buffers[i].view);
assert(!err);
}
@@ -731,7 +734,7 @@
demo->depth.format = depth_format;
/* create image */
- err = vkCreateImage(demo->device, &image,
+ err = vkCreateImage(demo->device, &image, NULL,
&demo->depth.image);
assert(!err);
@@ -748,7 +751,7 @@
assert(pass);
/* allocate memory */
- err = vkAllocMemory(demo->device, &mem_alloc, &demo->depth.mem);
+ err = vkAllocMemory(demo->device, &mem_alloc, NULL, &demo->depth.mem);
assert(!err);
/* bind memory */
@@ -763,7 +766,7 @@
/* create image view */
view.image = demo->depth.image;
- err = vkCreateImageView(demo->device, &view, &demo->depth.view);
+ err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
assert(!err);
}
@@ -805,7 +808,7 @@
VkMemoryRequirements mem_reqs;
- err = vkCreateImage(demo->device, &image_create_info,
+ err = vkCreateImage(demo->device, &image_create_info, NULL,
&tex_obj->image);
assert(!err);
@@ -816,7 +819,7 @@
assert(pass);
/* allocate memory */
- err = vkAllocMemory(demo->device, &mem_alloc, &tex_obj->mem);
+ err = vkAllocMemory(demo->device, &mem_alloc, NULL, &tex_obj->mem);
assert(!err);
/* bind memory */
@@ -859,8 +862,8 @@
static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_obj)
{
/* clean up staging resources */
- vkDestroyImage(demo->device, tex_obj->image);
- vkFreeMemory(demo->device, tex_obj->mem);
+ vkDestroyImage(demo->device, tex_obj->image, NULL);
+ vkFreeMemory(demo->device, tex_obj->mem, NULL);
}
static void demo_prepare_textures(struct demo *demo)
@@ -960,13 +963,13 @@
};
/* create sampler */
- err = vkCreateSampler(demo->device, &sampler,
+ err = vkCreateSampler(demo->device, &sampler, NULL,
&demo->textures[i].sampler);
assert(!err);
/* create image view */
view.image = demo->textures[i].image;
- err = vkCreateImageView(demo->device, &view,
+ err = vkCreateImageView(demo->device, &view, NULL,
&demo->textures[i].view);
assert(!err);
}
@@ -1000,7 +1003,7 @@
memset(&demo->vertices, 0, sizeof(demo->vertices));
- err = vkCreateBuffer(demo->device, &buf_info, &demo->vertices.buf);
+ err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->vertices.buf);
assert(!err);
vkGetBufferMemoryRequirements(demo->device,
@@ -1014,7 +1017,7 @@
&mem_alloc.memoryTypeIndex);
assert(pass);
- err = vkAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
+ err = vkAllocMemory(demo->device, &mem_alloc, NULL, &demo->vertices.mem);
assert(!err);
err = vkMapMemory(demo->device, demo->vertices.mem, 0, mem_alloc.allocationSize, 0, &data);
@@ -1067,7 +1070,7 @@
VkResult U_ASSERT_ONLY err;
err = vkCreateDescriptorSetLayout(demo->device,
- &descriptor_layout, &demo->desc_layout);
+ &descriptor_layout, NULL, &demo->desc_layout);
assert(!err);
const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
@@ -1079,6 +1082,7 @@
err = vkCreatePipelineLayout(demo->device,
&pPipelineLayoutCreateInfo,
+ NULL,
&demo->pipeline_layout);
assert(!err);
}
@@ -1144,7 +1148,7 @@
};
VkResult U_ASSERT_ONLY err;
- err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
+ err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
assert(!err);
}
@@ -1170,14 +1174,14 @@
moduleCreateInfo.codeSize = size;
moduleCreateInfo.pCode = code;
moduleCreateInfo.flags = 0;
- err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+ err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
assert(!err);
shaderCreateInfo.flags = 0;
shaderCreateInfo.module = *pShaderModule;
shaderCreateInfo.pName = "main";
shaderCreateInfo.stage = stage;
- err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+ err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
assert(!err);
} else {
// Create fake SPV structure to feed GLSL
@@ -1192,14 +1196,14 @@
((uint32_t *) moduleCreateInfo.pCode)[2] = stage;
memcpy(((uint32_t *) moduleCreateInfo.pCode + 3), code, size + 1);
- err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+ err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
assert(!err);
shaderCreateInfo.flags = 0;
shaderCreateInfo.module = *pShaderModule;
shaderCreateInfo.pName = "main";
shaderCreateInfo.stage = stage;
- err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+ err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
assert(!err);
free((void *) moduleCreateInfo.pCode);
}
@@ -1397,18 +1401,19 @@
memset(&pipelineCache, 0, sizeof(pipelineCache));
pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
- err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache);
+ err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
assert(!err);
- err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline);
+ err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache,
+ 1, &pipeline, NULL, &demo->pipeline);
assert(!err);
- vkDestroyPipelineCache(demo->device, demo->pipelineCache);
+ vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
for (uint32_t i = 0; i < pipeline.stageCount; i++) {
- vkDestroyShader(demo->device, shaderStages[i].shader);
+ vkDestroyShader(demo->device, shaderStages[i].shader, NULL);
}
- vkDestroyShaderModule(demo->device, demo->frag_shader_module);
- vkDestroyShaderModule(demo->device, demo->vert_shader_module);
+ vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
+ vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
}
static void demo_prepare_descriptor_pool(struct demo *demo)
@@ -1427,7 +1432,7 @@
VkResult U_ASSERT_ONLY err;
err = vkCreateDescriptorPool(demo->device,
- &descriptor_pool, &demo->desc_pool);
+ &descriptor_pool, NULL, &demo->desc_pool);
assert(!err);
}
@@ -1488,7 +1493,7 @@
for (i = 0; i < demo->swapchainImageCount; i++) {
attachments[0]= demo->buffers[i].view;
- err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
+ err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->framebuffers[i]);
assert(!err);
}
}
@@ -1503,7 +1508,7 @@
.queueFamilyIndex = demo->graphics_queue_node_index,
.flags = 0,
};
- err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
+ err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
assert(!err);
const VkCmdBufferAllocInfo cmd = {
@@ -1759,7 +1764,7 @@
void* pUserData,
size_t size,
size_t alignment,
- VkSystemAllocType allocType)
+ VkSystemAllocScope allocScope)
{
return malloc(size);
}
@@ -1850,16 +1855,10 @@
.engineVersion = 0,
.apiVersion = VK_API_VERSION,
};
- VkAllocCallbacks cb = {
- .pUserData = NULL,
- .pfnAlloc = myalloc,
- .pfnFree = myfree,
- };
VkInstanceCreateInfo inst_info = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL,
.pAppInfo = &app,
- .pAllocCb = &cb,
.enabledLayerNameCount = enabled_layer_count,
.ppEnabledLayerNames = (const char *const*) layer_names,
.enabledExtensionNameCount = enabled_extension_count,
@@ -1875,7 +1874,10 @@
};
uint32_t gpu_count;
- err = vkCreateInstance(&inst_info, &demo->inst);
+ demo->allocator.pfnAlloc = myalloc;
+ demo->allocator.pfnFree = myfree;
+
+ err = vkCreateInstance(&inst_info, &demo->allocator, &demo->inst);
if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
"(ICD).\n\nPlease look at the Getting Started guide for "
@@ -1996,7 +1998,7 @@
}
- err = vkCreateDevice(demo->gpu, &device, &demo->device);
+ err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
assert(!err);
GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
@@ -2207,45 +2209,45 @@
demo->prepared = false;
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+ vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
}
free(demo->framebuffers);
- vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+ vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
if (demo->setup_cmd) {
vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->setup_cmd);
}
vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->draw_cmd);
- vkDestroyCommandPool(demo->device, demo->cmd_pool);
+ vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
- vkDestroyPipeline(demo->device, demo->pipeline);
- vkDestroyRenderPass(demo->device, demo->render_pass);
- vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
- vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+ vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+ vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+ vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
- vkDestroyBuffer(demo->device, demo->vertices.buf);
- vkFreeMemory(demo->device, demo->vertices.mem);
+ vkDestroyBuffer(demo->device, demo->vertices.buf, NULL);
+ vkFreeMemory(demo->device, demo->vertices.mem, NULL);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
- vkDestroyImageView(demo->device, demo->textures[i].view);
- vkDestroyImage(demo->device, demo->textures[i].image);
- vkFreeMemory(demo->device, demo->textures[i].mem);
- vkDestroySampler(demo->device, demo->textures[i].sampler);
+ vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+ vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+ vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+ vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
}
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyImageView(demo->device, demo->buffers[i].view);
+ vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
}
- vkDestroyImageView(demo->device, demo->depth.view);
- vkDestroyImage(demo->device, demo->depth.image);
- vkFreeMemory(demo->device, demo->depth.mem);
+ vkDestroyImageView(demo->device, demo->depth.view, NULL);
+ vkDestroyImage(demo->device, demo->depth.image, NULL);
+ vkFreeMemory(demo->device, demo->depth.mem, NULL);
demo->fpDestroySwapchainKHR(demo->device, demo->swapchain);
free(demo->buffers);
- vkDestroyDevice(demo->device);
- vkDestroyInstance(demo->inst);
+ vkDestroyDevice(demo->device, NULL);
+ vkDestroyInstance(demo->inst, &demo->allocator);
free(demo->queue_props);
@@ -2271,39 +2273,39 @@
demo->prepared = false;
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+ vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
}
free(demo->framebuffers);
- vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+ vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
if (demo->setup_cmd) {
vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->setup_cmd);
}
vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->draw_cmd);
- vkDestroyCommandPool(demo->device, demo->cmd_pool);
+ vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
- vkDestroyPipeline(demo->device, demo->pipeline);
- vkDestroyRenderPass(demo->device, demo->render_pass);
- vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
- vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+ vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+ vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+ vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
- vkDestroyBuffer(demo->device, demo->vertices.buf);
- vkFreeMemory(demo->device, demo->vertices.mem);
+ vkDestroyBuffer(demo->device, demo->vertices.buf, NULL);
+ vkFreeMemory(demo->device, demo->vertices.mem, NULL);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
- vkDestroyImageView(demo->device, demo->textures[i].view);
- vkDestroyImage(demo->device, demo->textures[i].image);
- vkFreeMemory(demo->device, demo->textures[i].mem);
- vkDestroySampler(demo->device, demo->textures[i].sampler);
+ vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+ vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+ vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+ vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
}
for (i = 0; i < demo->swapchainImageCount; i++) {
- vkDestroyImageView(demo->device, demo->buffers[i].view);
+ vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
}
- vkDestroyImageView(demo->device, demo->depth.view);
- vkDestroyImage(demo->device, demo->depth.image);
- vkFreeMemory(demo->device, demo->depth.mem);
+ vkDestroyImageView(demo->device, demo->depth.view, NULL);
+ vkDestroyImage(demo->device, demo->depth.image, NULL);
+ vkFreeMemory(demo->device, demo->depth.mem, NULL);
free(demo->buffers);
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index 91ded08..69b2896 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -480,7 +480,7 @@
info.enabledExtensionNameCount = enabled_extension_count;
info.ppEnabledExtensionNames = (const char*const*) known_extensions;
dev->gpu = gpu;
- err = vkCreateDevice(gpu->obj, &info, &dev->obj);
+ err = vkCreateDevice(gpu->obj, &info, NULL, &dev->obj);
if (err)
ERR_EXIT(err);
@@ -488,7 +488,7 @@
static void app_dev_destroy(struct app_dev *dev)
{
- vkDestroyDevice(dev->obj);
+ vkDestroyDevice(dev->obj, NULL);
}
static void app_get_global_layer_extensions(
@@ -532,7 +532,6 @@
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL,
.pAppInfo = &app_info,
- .pAllocCb = NULL,
.enabledLayerNameCount = 0,
.ppEnabledLayerNames = NULL,
.enabledExtensionNameCount = 0,
@@ -613,7 +612,7 @@
inst_info.enabledExtensionNameCount = global_extension_count;
inst_info.ppEnabledExtensionNames = (const char * const *) known_extensions;
- err = vkCreateInstance(&inst_info, &inst->instance);
+ err = vkCreateInstance(&inst_info, NULL, &inst->instance);
if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
printf("Cannot create Vulkan instance.\n");
ERR_EXIT(err);
@@ -625,7 +624,7 @@
static void app_destroy_instance(struct app_instance *inst)
{
free(inst->global_extensions);
- vkDestroyInstance(inst->instance);
+ vkDestroyInstance(inst->instance, NULL);
}
diff --git a/icd/common/icd-enumerate-drm.c b/icd/common/icd-enumerate-drm.c
index 9941b65..050eac3 100644
--- a/icd/common/icd-enumerate-drm.c
+++ b/icd/common/icd-enumerate-drm.c
@@ -125,7 +125,7 @@
return devices;
} else {
dev = icd_instance_alloc(instance, sizeof(*dev), 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP);
+ VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
if (!dev)
return devices;
diff --git a/icd/common/icd-instance.c b/icd/common/icd-instance.c
index b792048..20febda 100644
--- a/icd/common/icd-instance.c
+++ b/icd/common/icd-instance.c
@@ -33,7 +33,7 @@
static void * VKAPI default_alloc(void *user_data, size_t size,
size_t alignment,
- VkSystemAllocType allocType)
+ VkSystemAllocScope allocScope)
{
if (alignment <= 1) {
return malloc(size);
@@ -80,7 +80,7 @@
alloc_cb = &default_alloc_cb;
instance = alloc_cb->pfnAlloc(alloc_cb->pUserData, sizeof(*instance), 0,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!instance)
return NULL;
@@ -89,7 +89,7 @@
name = (app_info->pAppName) ? app_info->pAppName : "unnamed";
len = strlen(name);
instance->name = alloc_cb->pfnAlloc(alloc_cb->pUserData, len + 1, 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!instance->name) {
alloc_cb->pfnFree(alloc_cb->pUserData, instance);
return NULL;
@@ -133,7 +133,7 @@
// }
logger = icd_instance_alloc(instance, sizeof(*logger), 0,
- VK_SYSTEM_ALLOC_TYPE_DEBUG);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!logger)
return VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/icd/common/icd-instance.h b/icd/common/icd-instance.h
index 400c642..d54af4e 100644
--- a/icd/common/icd-instance.h
+++ b/icd/common/icd-instance.h
@@ -57,10 +57,10 @@
static inline void *icd_instance_alloc(const struct icd_instance *instance,
size_t size, size_t alignment,
- VkSystemAllocType type)
+ VkSystemAllocScope scope)
{
return instance->alloc_cb.pfnAlloc(instance->alloc_cb.pUserData,
- size, alignment, type);
+ size, alignment, scope);
}
static inline void icd_instance_free(const struct icd_instance *instance,
diff --git a/icd/intel/buf.c b/icd/intel/buf.c
index a776828..2e2c176 100644
--- a/icd/intel/buf.c
+++ b/icd/intel/buf.c
@@ -91,6 +91,7 @@
ICD_EXPORT VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBuffer* pBuffer)
{
struct intel_dev *dev = intel_dev(device);
@@ -100,10 +101,10 @@
ICD_EXPORT void VKAPI vkDestroyBuffer(
VkDevice device,
- VkBuffer buffer)
-
- {
+ VkBuffer buffer,
+ const VkAllocCallbacks* pAllocator)
+{
struct intel_obj *obj = intel_obj(buffer);
obj->destroy(obj);
- }
+}
diff --git a/icd/intel/cmd.c b/icd/intel/cmd.c
index 6d71433..4ee3c15 100644
--- a/icd/intel/cmd.c
+++ b/icd/intel/cmd.c
@@ -194,7 +194,7 @@
struct intel_cmd_item *items;
items = intel_alloc(cmd, sizeof(writer->items[0]) * new_alloc,
- 0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!items) {
writer->item_used = 0;
cmd_fail(cmd, VK_ERROR_OUT_OF_HOST_MEMORY);
@@ -296,7 +296,7 @@
*/
cmd->reloc_count = dev->gpu->batch_buffer_reloc_count;
cmd->relocs = intel_alloc(cmd, sizeof(cmd->relocs[0]) * cmd->reloc_count,
- 4096, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 4096, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!cmd->relocs) {
intel_cmd_destroy(cmd);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -472,6 +472,7 @@
ICD_EXPORT VkResult VKAPI vkCreateCommandPool(
VkDevice device,
const VkCmdPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkCmdPool* pCmdPool)
{
struct intel_dev *dev = intel_dev(device);
@@ -482,7 +483,8 @@
ICD_EXPORT void VKAPI vkDestroyCommandPool(
VkDevice device,
- VkCmdPool cmdPool)
+ VkCmdPool cmdPool,
+ const VkAllocCallbacks* pAllocator)
{
}
diff --git a/icd/intel/cmd_pipeline.c b/icd/intel/cmd_pipeline.c
index 28c92b2..e654369 100644
--- a/icd/intel/cmd_pipeline.c
+++ b/icd/intel/cmd_pipeline.c
@@ -2099,7 +2099,7 @@
void *entries;
entries = intel_alloc(cmd, sizeof(cache->entries[0]) * count, 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (entries) {
if (cache->entries) {
memcpy(entries, cache->entries,
@@ -3300,7 +3300,7 @@
data->set_offsets = intel_alloc(cmd,
sizeof(data->set_offsets[0]) * pipeline_layout->layout_count,
- sizeof(data->set_offsets[0]), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ sizeof(data->set_offsets[0]), VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!data->set_offsets) {
cmd_fail(cmd, VK_ERROR_OUT_OF_HOST_MEMORY);
data->set_offset_count = 0;
@@ -3316,7 +3316,7 @@
data->dynamic_offsets = intel_alloc(cmd,
sizeof(data->dynamic_offsets[0]) * pipeline_layout->total_dynamic_desc_count,
- sizeof(data->dynamic_offsets[0]), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ sizeof(data->dynamic_offsets[0]), VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!data->dynamic_offsets) {
cmd_fail(cmd, VK_ERROR_OUT_OF_HOST_MEMORY);
data->dynamic_offset_count = 0;
diff --git a/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp b/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
index 23d7144..75e34e6 100644
--- a/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
+++ b/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
@@ -345,12 +345,12 @@
static inline void *pipe_interface_alloc(const void *handle,
size_t size, size_t alignment,
- VkSystemAllocType type)
+ VkSystemAllocScope scope)
{
if (standaloneCompiler)
return calloc(size, sizeof(char));
else
- return intel_alloc(handle, size, alignment, type);
+ return intel_alloc(handle, size, alignment, scope);
}
static void rmap_destroy(const struct intel_gpu *gpu,
@@ -369,7 +369,7 @@
uint32_t surface_count, i;
rmap = (struct intel_pipeline_rmap *)
- pipe_interface_alloc(gpu, sizeof(*rmap), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ pipe_interface_alloc(gpu, sizeof(*rmap), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!rmap)
return NULL;
@@ -390,7 +390,7 @@
rmap->slots = (struct intel_pipeline_rmap_slot *)
pipe_interface_alloc(gpu, sizeof(rmap->slots[0]) * rmap->slot_count,
- 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!rmap->slots) {
pipe_interface_free(gpu, rmap);
return NULL;
@@ -638,7 +638,7 @@
{
pipe_shader->codeSize = get_vs_program_size(brw->shader_prog);
- pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER);
+ pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!pipe_shader->pCode) {
status = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -709,7 +709,7 @@
{
pipe_shader->codeSize = get_gs_program_size(brw->shader_prog);
- pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER);
+ pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!pipe_shader->pCode) {
status = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -786,7 +786,7 @@
pipe_shader->codeSize = get_wm_program_size(brw->shader_prog);
- pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER);
+ pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!pipe_shader->pCode) {
status = VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp b/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp
index bc1bf47..40053e8 100644
--- a/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp
+++ b/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp
@@ -621,7 +621,7 @@
prog = get_program(&prog_size, stderr);
- code = intel_alloc(gpu, prog_size, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ code = intel_alloc(gpu, prog_size, 0, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
if (!code)
return NULL;
diff --git a/icd/intel/compiler/shader/standalone_utils.c b/icd/intel/compiler/shader/standalone_utils.c
index bb70706..4c96fd2 100644
--- a/icd/intel/compiler/shader/standalone_utils.c
+++ b/icd/intel/compiler/shader/standalone_utils.c
@@ -38,11 +38,11 @@
void *intel_alloc(const void *handle,
size_t size, size_t alignment,
- VkSystemAllocType type)
+ VkSystemAllocScope scope)
{
assert(intel_handle_validate(handle));
return icd_instance_alloc(((const struct intel_handle *) handle)->instance->icd,
- size, alignment, type);
+ size, alignment, scope);
}
void intel_free(const void *handle, void *ptr)
diff --git a/icd/intel/desc.c b/icd/intel/desc.c
index ab50390..7fa9653 100644
--- a/icd/intel/desc.c
+++ b/icd/intel/desc.c
@@ -121,7 +121,7 @@
const uint32_t sampler_count = 1024*1024;
struct intel_desc_region *region;
- region = intel_alloc(dev, sizeof(*region), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ region = intel_alloc(dev, sizeof(*region), 0, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
if (!region)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -134,14 +134,14 @@
region->sampler_desc_size * sampler_count);
region->surfaces = intel_alloc(dev, region->size.surface,
- 64, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 64, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
if (!region->surfaces) {
intel_free(dev, region);
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
region->samplers = intel_alloc(dev, region->size.sampler,
- 64, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 64, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
if (!region->samplers) {
intel_free(dev, region->surfaces);
intel_free(dev, region);
@@ -562,7 +562,7 @@
/* allocate bindings */
layout->bindings = intel_alloc(layout, sizeof(layout->bindings[0]) *
- info->bindingCount, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ info->bindingCount, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!layout->bindings)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -618,7 +618,7 @@
} else {
binding->immutable_samplers = intel_alloc(layout,
sizeof(binding->immutable_samplers[0]) * lb->arraySize,
- 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!binding->immutable_samplers)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -705,7 +705,7 @@
pipeline_layout->layouts = intel_alloc(pipeline_layout,
sizeof(pipeline_layout->layouts[0]) * count,
- 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!pipeline_layout->layouts) {
intel_pipeline_layout_destroy(pipeline_layout);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -713,7 +713,7 @@
pipeline_layout->dynamic_desc_indices = intel_alloc(pipeline_layout,
sizeof(pipeline_layout->dynamic_desc_indices[0]) * count,
- 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!pipeline_layout->dynamic_desc_indices) {
intel_pipeline_layout_destroy(pipeline_layout);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -748,6 +748,7 @@
ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
struct intel_dev *dev = intel_dev(device);
@@ -758,7 +759,8 @@
ICD_EXPORT void VKAPI vkDestroyDescriptorSetLayout(
VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout)
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(descriptorSetLayout);
@@ -769,6 +771,7 @@
ICD_EXPORT VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
struct intel_dev *dev = intel_dev(device);
@@ -780,7 +783,8 @@
ICD_EXPORT void VKAPI vkDestroyPipelineLayout(
VkDevice device,
- VkPipelineLayout pipelineLayout)
+ VkPipelineLayout pipelineLayout,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(pipelineLayout);
@@ -791,6 +795,7 @@
ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
struct intel_dev *dev = intel_dev(device);
@@ -801,7 +806,8 @@
ICD_EXPORT void VKAPI vkDestroyDescriptorPool(
VkDevice device,
- VkDescriptorPool descriptorPool)
+ VkDescriptorPool descriptorPool,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(descriptorPool);
diff --git a/icd/intel/dev.c b/icd/intel/dev.c
index 4e41752..3ebcaf3 100644
--- a/icd/intel/dev.c
+++ b/icd/intel/dev.c
@@ -212,6 +212,7 @@
ICD_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice gpu_,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice)
{
struct intel_gpu *gpu = intel_gpu(gpu_);
@@ -220,7 +221,8 @@
}
ICD_EXPORT void VKAPI vkDestroyDevice(
- VkDevice device)
+ VkDevice device,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_dev *dev = intel_dev(device);
diff --git a/icd/intel/event.c b/icd/intel/event.c
index f2ac3d6..e254c60 100644
--- a/icd/intel/event.c
+++ b/icd/intel/event.c
@@ -142,6 +142,7 @@
ICD_EXPORT VkResult VKAPI vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkEvent* pEvent)
{
struct intel_dev *dev = intel_dev(device);
@@ -152,7 +153,8 @@
ICD_EXPORT void VKAPI vkDestroyEvent(
VkDevice device,
- VkEvent event)
+ VkEvent event,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(event);
diff --git a/icd/intel/fb.c b/icd/intel/fb.c
index 2950c47..5a21546 100644
--- a/icd/intel/fb.c
+++ b/icd/intel/fb.c
@@ -38,6 +38,7 @@
VkResult intel_fb_create(struct intel_dev *dev,
const VkFramebufferCreateInfo *info,
+ const VkAllocCallbacks *allocator,
struct intel_fb **fb_ret)
{
struct intel_fb *fb;
@@ -50,7 +51,7 @@
fb->view_count = info->attachmentCount;
fb->views = intel_alloc(fb, sizeof(fb->views[0]) * fb->view_count, 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!fb->views) {
intel_fb_destroy(fb);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -97,6 +98,7 @@
VkResult intel_render_pass_create(struct intel_dev *dev,
const VkRenderPassCreateInfo *info,
+ const VkAllocCallbacks *allocator,
struct intel_render_pass **rp_ret)
{
struct intel_render_pass *rp;
@@ -116,7 +118,7 @@
rp->attachments = intel_alloc(rp,
sizeof(rp->attachments[0]) * rp->attachment_count +
sizeof(rp->subpasses[0]) * rp->subpass_count, 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!rp->attachments) {
intel_render_pass_destroy(rp);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -199,17 +201,19 @@
ICD_EXPORT VkResult VKAPI vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFramebuffer* pFramebuffer)
{
struct intel_dev *dev = intel_dev(device);
- return intel_fb_create(dev, pCreateInfo,
+ return intel_fb_create(dev, pCreateInfo, pAllocator,
(struct intel_fb **) pFramebuffer);
}
ICD_EXPORT void VKAPI vkDestroyFramebuffer(
VkDevice device,
- VkFramebuffer framebuffer)
+ VkFramebuffer framebuffer,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(framebuffer);
@@ -220,18 +224,19 @@
ICD_EXPORT VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
struct intel_dev *dev = intel_dev(device);
- return intel_render_pass_create(dev, pCreateInfo,
+ return intel_render_pass_create(dev, pCreateInfo, pAllocator,
(struct intel_render_pass **) pRenderPass);
}
ICD_EXPORT void VKAPI vkDestroyRenderPass(
VkDevice device,
- VkRenderPass renderPass)
-
+ VkRenderPass renderPass,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(renderPass);
diff --git a/icd/intel/fb.h b/icd/intel/fb.h
index eca65d2..fade414 100644
--- a/icd/intel/fb.h
+++ b/icd/intel/fb.h
@@ -96,13 +96,15 @@
}
VkResult intel_fb_create(struct intel_dev *dev,
- const VkFramebufferCreateInfo *pInfo,
- struct intel_fb **fb_ret);
+ const VkFramebufferCreateInfo *pInfo,
+ const VkAllocCallbacks *allocator,
+ struct intel_fb **fb_ret);
void intel_fb_destroy(struct intel_fb *fb);
VkResult intel_render_pass_create(struct intel_dev *dev,
- const VkRenderPassCreateInfo *pInfo,
- struct intel_render_pass **rp_ret);
+ const VkRenderPassCreateInfo *pInfo,
+ const VkAllocCallbacks *allocator,
+ struct intel_render_pass **rp_ret);
void intel_render_pass_destroy(struct intel_render_pass *rp);
#endif /* FB_H */
diff --git a/icd/intel/fence.c b/icd/intel/fence.c
index 91eaaf1..5669650 100644
--- a/icd/intel/fence.c
+++ b/icd/intel/fence.c
@@ -120,6 +120,7 @@
ICD_EXPORT VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFence* pFence)
{
struct intel_dev *dev = intel_dev(device);
@@ -130,7 +131,8 @@
ICD_EXPORT void VKAPI vkDestroyFence(
VkDevice device,
- VkFence fence)
+ VkFence fence,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(fence);
diff --git a/icd/intel/gpu.c b/icd/intel/gpu.c
index 223baf1..3a192e2 100644
--- a/icd/intel/gpu.c
+++ b/icd/intel/gpu.c
@@ -157,7 +157,7 @@
return VK_ERROR_INITIALIZATION_FAILED;
}
- gpu = intel_alloc(instance, sizeof(*gpu), 0, VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ gpu = intel_alloc(instance, sizeof(*gpu), 0, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!gpu)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -171,7 +171,7 @@
render_len = (render_node) ? strlen(render_node) : 0;
gpu->primary_node = intel_alloc(gpu, primary_len + 1 +
- ((render_len) ? (render_len + 1) : 0), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ ((render_len) ? (render_len + 1) : 0), 0, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!gpu->primary_node) {
intel_free(instance, gpu);
return VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/icd/intel/img.c b/icd/intel/img.c
index 9322973..1a72a5d 100644
--- a/icd/intel/img.c
+++ b/icd/intel/img.c
@@ -60,6 +60,7 @@
VkResult intel_img_create(struct intel_dev *dev,
const VkImageCreateInfo *info,
+ const VkAllocCallbacks *allocator,
bool scanout,
struct intel_img **img_ret)
{
@@ -93,7 +94,7 @@
VkImageCreateInfo s8_info;
img->s8_layout = intel_alloc(img, sizeof(*img->s8_layout), 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!img->s8_layout) {
intel_img_destroy(img);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -142,17 +143,19 @@
ICD_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImage* pImage)
{
struct intel_dev *dev = intel_dev(device);
- return intel_img_create(dev, pCreateInfo, false,
+ return intel_img_create(dev, pCreateInfo, pAllocator, false,
(struct intel_img **) pImage);
}
ICD_EXPORT void VKAPI vkDestroyImage(
VkDevice device,
- VkImage image)
+ VkImage image,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(image);
diff --git a/icd/intel/img.h b/icd/intel/img.h
index 9a79e47..b583dfe 100644
--- a/icd/intel/img.h
+++ b/icd/intel/img.h
@@ -70,9 +70,10 @@
}
VkResult intel_img_create(struct intel_dev *dev,
- const VkImageCreateInfo *info,
- bool scanout,
- struct intel_img **img_ret);
+ const VkImageCreateInfo *info,
+ const VkAllocCallbacks *allocator,
+ bool scanout,
+ struct intel_img **img_ret);
void intel_img_destroy(struct intel_img *img);
diff --git a/icd/intel/instance.c b/icd/intel/instance.c
index 890a513..bff0551 100644
--- a/icd/intel/instance.c
+++ b/icd/intel/instance.c
@@ -35,11 +35,11 @@
void *intel_alloc(const void *handle,
size_t size, size_t alignment,
- VkSystemAllocType type)
+ VkSystemAllocScope scope)
{
assert(intel_handle_validate(handle));
return icd_instance_alloc(((const struct intel_handle *) handle)->instance->icd,
- size, alignment, type);
+ size, alignment, scope);
}
void intel_free(const void *handle, void *ptr)
@@ -146,6 +146,7 @@
static VkResult intel_instance_create(
const VkInstanceCreateInfo* info,
+ const VkAllocCallbacks* allocator,
struct intel_instance **pInstance)
{
struct intel_instance *instance;
@@ -154,12 +155,12 @@
intel_debug_init();
- icd = icd_instance_create(info->pAppInfo, info->pAllocCb);
+ icd = icd_instance_create(info->pAppInfo, allocator);
if (!icd)
return VK_ERROR_OUT_OF_HOST_MEMORY;
instance = icd_instance_alloc(icd, sizeof(*instance), 0,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!instance) {
icd_instance_destroy(icd);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -219,13 +220,16 @@
ICD_EXPORT VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
- return intel_instance_create(pCreateInfo, (struct intel_instance **) pInstance);
+ return intel_instance_create(pCreateInfo, pAllocator,
+ (struct intel_instance **) pInstance);
}
ICD_EXPORT void VKAPI vkDestroyInstance(
- VkInstance pInstance)
+ VkInstance pInstance,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_instance *instance = intel_instance(pInstance);
diff --git a/icd/intel/intel.h b/icd/intel/intel.h
index e324f24..9628bb1 100644
--- a/icd/intel/intel.h
+++ b/icd/intel/intel.h
@@ -126,7 +126,7 @@
void *intel_alloc(const void *handle,
size_t size, size_t alignment,
- VkSystemAllocType type);
+ VkSystemAllocScope scope);
void intel_free(const void *handle, void *ptr);
diff --git a/icd/intel/kmd/winsys_drm.c b/icd/intel/kmd/winsys_drm.c
index 2c8a2b8..edc6e70 100644
--- a/icd/intel/kmd/winsys_drm.c
+++ b/icd/intel/kmd/winsys_drm.c
@@ -168,7 +168,7 @@
struct intel_winsys *winsys;
winsys = icd_instance_alloc(instance, sizeof(*winsys), 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!winsys)
return NULL;
diff --git a/icd/intel/mem.c b/icd/intel/mem.c
index 21936a5..b5e70a0 100644
--- a/icd/intel/mem.c
+++ b/icd/intel/mem.c
@@ -65,6 +65,7 @@
ICD_EXPORT VkResult VKAPI vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo* pAllocInfo,
+ const VkAllocCallbacks* pAllocator,
VkDeviceMemory* pMem)
{
struct intel_dev *dev = intel_dev(device);
@@ -74,7 +75,8 @@
ICD_EXPORT void VKAPI vkFreeMemory(
VkDevice device,
- VkDeviceMemory mem_)
+ VkDeviceMemory mem_,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_mem *mem = intel_mem(mem_);
diff --git a/icd/intel/obj.c b/icd/intel/obj.c
index 27135b9..a1c61a3 100644
--- a/icd/intel/obj.c
+++ b/icd/intel/obj.c
@@ -137,7 +137,7 @@
if (shallow_copy) {
dbg->create_info = intel_alloc(handle, shallow_copy, 0,
- VK_SYSTEM_ALLOC_TYPE_DEBUG);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!dbg->create_info)
return false;
@@ -152,7 +152,7 @@
size = sizeof(*src);
dbg->create_info_size = size;
- dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+ dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!dst)
return false;
memcpy(dst, src, sizeof(*src));
@@ -182,7 +182,7 @@
size += strlen(src->ppEnabledExtensionNames[i]) + 1;
}
- dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+ dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!dst)
return false;
@@ -239,7 +239,7 @@
assert(dbg_size >= sizeof(*dbg));
- dbg = intel_alloc(handle, dbg_size, 0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+ dbg = intel_alloc(handle, dbg_size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!dbg)
return NULL;
@@ -284,7 +284,7 @@
assert(obj_size >= sizeof(*base));
- base = intel_alloc(handle, obj_size, 0, VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ base = intel_alloc(handle, obj_size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!base)
return NULL;
diff --git a/icd/intel/pipeline.c b/icd/intel/pipeline.c
index 503e771..62f4860 100644
--- a/icd/intel/pipeline.c
+++ b/icd/intel/pipeline.c
@@ -207,7 +207,7 @@
struct intel_pipeline_shader *sh;
VkResult ret;
- sh = intel_alloc(dev, sizeof(*sh), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ sh = intel_alloc(dev, sizeof(*sh), 0, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
if (!sh)
return NULL;
memset(sh, 0, sizeof(*sh));
@@ -1350,6 +1350,7 @@
ICD_EXPORT VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
@@ -1360,7 +1361,8 @@
void VKAPI vkDestroyPipelineCache(
VkDevice device,
- VkPipelineCache pipelineCache)
+ VkPipelineCache pipelineCache,
+ const VkAllocCallbacks* pAllocator)
{
}
@@ -1387,6 +1389,7 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines)
{
struct intel_dev *dev = intel_dev(device);
@@ -1415,6 +1418,7 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines)
{
return VK_ERROR_VALIDATION_FAILED;
@@ -1422,7 +1426,8 @@
ICD_EXPORT void VKAPI vkDestroyPipeline(
VkDevice device,
- VkPipeline pipeline)
+ VkPipeline pipeline,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(pipeline);
diff --git a/icd/intel/query.c b/icd/intel/query.c
index 9cb6af2..88c647b 100644
--- a/icd/intel/query.c
+++ b/icd/intel/query.c
@@ -219,6 +219,7 @@
ICD_EXPORT VkResult VKAPI vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkQueryPool* pQueryPool)
{
struct intel_dev *dev = intel_dev(device);
@@ -229,7 +230,8 @@
ICD_EXPORT void VKAPI vkDestroyQueryPool(
VkDevice device,
- VkQueryPool queryPool)
+ VkQueryPool queryPool,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(queryPool);
diff --git a/icd/intel/queue.c b/icd/intel/queue.c
index 5565a5f..7a47e28 100644
--- a/icd/intel/queue.c
+++ b/icd/intel/queue.c
@@ -439,6 +439,7 @@
ICD_EXPORT VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSemaphore *pSemaphore)
{
/*
@@ -459,7 +460,8 @@
ICD_EXPORT void VKAPI vkDestroySemaphore(
VkDevice device,
- VkSemaphore semaphore)
+ VkSemaphore semaphore,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(semaphore);
obj->destroy(obj);
diff --git a/icd/intel/sampler.c b/icd/intel/sampler.c
index 493d097..e5b946b 100644
--- a/icd/intel/sampler.c
+++ b/icd/intel/sampler.c
@@ -398,6 +398,7 @@
ICD_EXPORT VkResult VKAPI vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSampler* pSampler)
{
struct intel_dev *dev = intel_dev(device);
@@ -408,7 +409,8 @@
ICD_EXPORT void VKAPI vkDestroySampler(
VkDevice device,
- VkSampler sampler)
+ VkSampler sampler,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(sampler);
diff --git a/icd/intel/shader.c b/icd/intel/shader.c
index 9965d7e..d8a3146 100644
--- a/icd/intel/shader.c
+++ b/icd/intel/shader.c
@@ -68,6 +68,7 @@
ICD_EXPORT VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShaderModule* pShaderModule)
{
struct intel_dev *dev = intel_dev(device);
@@ -77,7 +78,8 @@
ICD_EXPORT void VKAPI vkDestroyShaderModule(
VkDevice device,
- VkShaderModule shaderModule)
+ VkShaderModule shaderModule,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(shaderModule);
@@ -127,6 +129,7 @@
ICD_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShader* pShader)
{
struct intel_dev *dev = intel_dev(device);
@@ -136,7 +139,8 @@
ICD_EXPORT void VKAPI vkDestroyShader(
VkDevice device,
- VkShader shader)
+ VkShader shader,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(shader);
diff --git a/icd/intel/view.c b/icd/intel/view.c
index 8593f53..b246927 100644
--- a/icd/intel/view.c
+++ b/icd/intel/view.c
@@ -1356,6 +1356,7 @@
ICD_EXPORT VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBufferView* pView)
{
struct intel_dev *dev = intel_dev(device);
@@ -1366,7 +1367,8 @@
ICD_EXPORT void VKAPI vkDestroyBufferView(
VkDevice device,
- VkBufferView bufferView)
+ VkBufferView bufferView,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(bufferView);
@@ -1377,6 +1379,7 @@
ICD_EXPORT VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImageView* pView)
{
struct intel_dev *dev = intel_dev(device);
@@ -1387,7 +1390,8 @@
ICD_EXPORT void VKAPI vkDestroyImageView(
VkDevice device,
- VkImageView imageView)
+ VkImageView imageView,
+ const VkAllocCallbacks* pAllocator)
{
struct intel_obj *obj = intel_obj(imageView);
diff --git a/icd/intel/wsi_x11.c b/icd/intel/wsi_x11.c
index dbcd2d6..77fe2f4 100644
--- a/icd/intel/wsi_x11.c
+++ b/icd/intel/wsi_x11.c
@@ -409,7 +409,7 @@
xcb_pixmap_t pixmap;
VkResult ret;
- ret = intel_img_create(dev, img_info, true, &img);
+ ret = intel_img_create(dev, img_info, NULL, true, &img);
if (ret != VK_SUCCESS)
return NULL;
@@ -456,12 +456,12 @@
uint32_t i;
images = intel_alloc(sc, sizeof(*images) * info->minImageCount,
- 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!images)
return false;
image_state = intel_alloc(
sc, sizeof(intel_x11_swap_chain_image_state) * info->minImageCount,
- 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!image_state) {
for (i = 0; i < info->minImageCount; i++) {
intel_img_destroy(images[i]);
@@ -471,7 +471,7 @@
}
present_queue = intel_alloc(
sc, sizeof(uint32_t) * info->minImageCount,
- 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!present_queue) {
for (i = 0; i < info->minImageCount; i++) {
intel_img_destroy(images[i]);
@@ -786,7 +786,7 @@
close(fd);
- sc = intel_alloc(dev, sizeof(*sc), 0, VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ sc = intel_alloc(dev, sizeof(*sc), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!sc)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -843,7 +843,7 @@
{
struct intel_x11_img_data *data;
- data = intel_alloc(img, sizeof(*data), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ data = intel_alloc(img, sizeof(*data), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!data)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -872,7 +872,7 @@
{
struct intel_x11_fence_data *data;
- data = intel_alloc(fence, sizeof(*data), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ data = intel_alloc(fence, sizeof(*data), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!data)
return VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index b217e22..a0e175a 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -611,6 +611,7 @@
ICD_EXPORT VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBuffer* pBuffer)
{
NULLDRV_LOG_FUNC;
@@ -621,7 +622,8 @@
ICD_EXPORT void VKAPI vkDestroyBuffer(
VkDevice device,
- VkBuffer buffer)
+ VkBuffer buffer,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -629,6 +631,7 @@
ICD_EXPORT VkResult VKAPI vkCreateCommandPool(
VkDevice device,
const VkCmdPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkCmdPool* pCmdPool)
{
NULLDRV_LOG_FUNC;
@@ -637,7 +640,8 @@
ICD_EXPORT void VKAPI vkDestroyCommandPool(
VkDevice device,
- VkCmdPool cmdPool)
+ VkCmdPool cmdPool,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1237,6 +1241,7 @@
ICD_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice gpu_,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice)
{
NULLDRV_LOG_FUNC;
@@ -1245,7 +1250,8 @@
}
ICD_EXPORT void VKAPI vkDestroyDevice(
- VkDevice device)
+ VkDevice device,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1271,6 +1277,7 @@
ICD_EXPORT VkResult VKAPI vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkEvent* pEvent)
{
NULLDRV_LOG_FUNC;
@@ -1279,7 +1286,8 @@
ICD_EXPORT void VKAPI vkDestroyEvent(
VkDevice device,
- VkEvent event)
+ VkEvent event,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1311,6 +1319,7 @@
ICD_EXPORT VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFence* pFence)
{
NULLDRV_LOG_FUNC;
@@ -1322,7 +1331,8 @@
ICD_EXPORT void VKAPI vkDestroyFence(
VkDevice device,
- VkFence fence)
+ VkFence fence,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1468,6 +1478,7 @@
ICD_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImage* pImage)
{
NULLDRV_LOG_FUNC;
@@ -1479,7 +1490,8 @@
ICD_EXPORT void VKAPI vkDestroyImage(
VkDevice device,
- VkImage image)
+ VkImage image,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1501,6 +1513,7 @@
ICD_EXPORT VkResult VKAPI vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo* pAllocInfo,
+ const VkAllocCallbacks* pAllocator,
VkDeviceMemory* pMem)
{
NULLDRV_LOG_FUNC;
@@ -1511,7 +1524,8 @@
ICD_EXPORT void VKAPI vkFreeMemory(
VkDevice device,
- VkDeviceMemory mem_)
+ VkDeviceMemory mem_,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1567,6 +1581,7 @@
ICD_EXPORT VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
NULLDRV_LOG_FUNC;
@@ -1585,7 +1600,8 @@
}
ICD_EXPORT void VKAPI vkDestroyInstance(
- VkInstance pInstance)
+ VkInstance pInstance,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1712,6 +1728,7 @@
ICD_EXPORT VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
@@ -1721,14 +1738,16 @@
ICD_EXPORT void VKAPI vkDestroyPipeline(
VkDevice device,
- VkPipeline pipeline)
+ VkPipeline pipeline,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
void VKAPI vkDestroyPipelineCache(
VkDevice device,
- VkPipelineCache pipelineCache)
+ VkPipelineCache pipelineCache,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1757,6 +1776,7 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipeline)
{
NULLDRV_LOG_FUNC;
@@ -1773,6 +1793,7 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipeline)
{
NULLDRV_LOG_FUNC;
@@ -1786,6 +1807,7 @@
ICD_EXPORT VkResult VKAPI vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkQueryPool* pQueryPool)
{
NULLDRV_LOG_FUNC;
@@ -1794,7 +1816,8 @@
ICD_EXPORT void VKAPI vkDestroyQueryPool(
VkDevice device,
- VkQueryPool queryPoool)
+ VkQueryPool queryPoool,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1833,6 +1856,7 @@
ICD_EXPORT VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSemaphore* pSemaphore)
{
NULLDRV_LOG_FUNC;
@@ -1841,7 +1865,8 @@
ICD_EXPORT void VKAPI vkDestroySemaphore(
VkDevice device,
- VkSemaphore semaphore)
+ VkSemaphore semaphore,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1849,6 +1874,7 @@
ICD_EXPORT VkResult VKAPI vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSampler* pSampler)
{
NULLDRV_LOG_FUNC;
@@ -1860,7 +1886,8 @@
ICD_EXPORT void VKAPI vkDestroySampler(
VkDevice device,
- VkSampler sampler)
+ VkSampler sampler,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1868,6 +1895,7 @@
ICD_EXPORT VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShaderModule* pShaderModule)
{
// TODO: Fill in with real data
@@ -1877,7 +1905,8 @@
ICD_EXPORT void VKAPI vkDestroyShaderModule(
VkDevice device,
- VkShaderModule shaderModule)
+ VkShaderModule shaderModule,
+ const VkAllocCallbacks* pAllocator)
{
// TODO: Fill in with real data
NULLDRV_LOG_FUNC;
@@ -1886,6 +1915,7 @@
ICD_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShader* pShader)
{
NULLDRV_LOG_FUNC;
@@ -1896,7 +1926,8 @@
ICD_EXPORT void VKAPI vkDestroyShader(
VkDevice device,
- VkShader shader)
+ VkShader shader,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1904,6 +1935,7 @@
ICD_EXPORT VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBufferView* pView)
{
NULLDRV_LOG_FUNC;
@@ -1915,7 +1947,8 @@
ICD_EXPORT void VKAPI vkDestroyBufferView(
VkDevice device,
- VkBufferView bufferView)
+ VkBufferView bufferView,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1923,6 +1956,7 @@
ICD_EXPORT VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImageView* pView)
{
NULLDRV_LOG_FUNC;
@@ -1934,7 +1968,8 @@
ICD_EXPORT void VKAPI vkDestroyImageView(
VkDevice device,
- VkImageView imageView)
+ VkImageView imageView,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1942,6 +1977,7 @@
ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
NULLDRV_LOG_FUNC;
@@ -1953,7 +1989,8 @@
ICD_EXPORT void VKAPI vkDestroyDescriptorSetLayout(
VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout)
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1961,6 +1998,7 @@
ICD_EXPORT VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
NULLDRV_LOG_FUNC;
@@ -1973,7 +2011,8 @@
ICD_EXPORT void VKAPI vkDestroyPipelineLayout(
VkDevice device,
- VkPipelineLayout pipelineLayout)
+ VkPipelineLayout pipelineLayout,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -1981,6 +2020,7 @@
ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
NULLDRV_LOG_FUNC;
@@ -1992,7 +2032,8 @@
ICD_EXPORT void VKAPI vkDestroyDescriptorPool(
VkDevice device,
- VkDescriptorPool descriptorPool)
+ VkDescriptorPool descriptorPool,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -2053,6 +2094,7 @@
ICD_EXPORT VkResult VKAPI vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* info,
+ const VkAllocCallbacks* pAllocator,
VkFramebuffer* fb_ret)
{
NULLDRV_LOG_FUNC;
@@ -2063,7 +2105,8 @@
ICD_EXPORT void VKAPI vkDestroyFramebuffer(
VkDevice device,
- VkFramebuffer framebuffer)
+ VkFramebuffer framebuffer,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
@@ -2071,6 +2114,7 @@
ICD_EXPORT VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* info,
+ const VkAllocCallbacks* pAllocator,
VkRenderPass* rp_ret)
{
NULLDRV_LOG_FUNC;
@@ -2081,7 +2125,8 @@
ICD_EXPORT void VKAPI vkDestroyRenderPass(
VkDevice device,
- VkRenderPass renderPass)
+ VkRenderPass renderPass,
+ const VkAllocCallbacks* pAllocator)
{
NULLDRV_LOG_FUNC;
}
diff --git a/include/vulkan.h b/include/vulkan.h
index 6624b8e..f7e6cc3 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -189,16 +189,24 @@
} VkStructureType;
typedef enum {
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3,
- VK_SYSTEM_ALLOC_TYPE_DEBUG = 4,
- VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT,
- VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG,
- VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1),
- VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkSystemAllocType;
+ VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0,
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT = 1,
+ VK_SYSTEM_ALLOC_SCOPE_CACHE = 2,
+ VK_SYSTEM_ALLOC_SCOPE_DEVICE = 3,
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 4,
+ VK_SYSTEM_ALLOC_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_SCOPE_FUNCTION,
+ VK_SYSTEM_ALLOC_SCOPE_END_RANGE = VK_SYSTEM_ALLOC_SCOPE_INSTANCE,
+ VK_SYSTEM_ALLOC_SCOPE_NUM = (VK_SYSTEM_ALLOC_SCOPE_INSTANCE - VK_SYSTEM_ALLOC_SCOPE_FUNCTION + 1),
+ VK_SYSTEM_ALLOC_SCOPE_MAX_ENUM = 0x7FFFFFFF
+} VkSystemAllocScope;
+
+typedef enum {
+ VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0,
+ VK_INTERNAL_ALLOC_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
+ VK_INTERNAL_ALLOC_TYPE_END_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
+ VK_INTERNAL_ALLOC_TYPE_NUM = (VK_INTERNAL_ALLOC_TYPE_EXECUTABLE - VK_INTERNAL_ALLOC_TYPE_EXECUTABLE + 1),
+ VK_INTERNAL_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkInternalAllocType;
typedef enum {
VK_FORMAT_UNDEFINED = 0,
@@ -1023,15 +1031,34 @@
typedef VkFlags VkQueryControlFlags;
typedef void* (VKAPI *PFN_vkAllocFunction)(
- void* pUserData,
- size_t size,
- size_t alignment,
- VkSystemAllocType allocType);
+ void* pUserData,
+ size_t size,
+ size_t alignment,
+ VkSystemAllocScope allocScope);
+
+typedef void* (VKAPI *PFN_vkReallocFunction)(
+ void* pUserData,
+ void* pOriginal,
+ size_t size,
+ size_t alignment,
+ VkSystemAllocScope allocScope);
typedef void (VKAPI *PFN_vkFreeFunction)(
void* pUserData,
void* pMem);
+typedef void (VKAPI *PFN_vkInternalAllocNotification)(
+ void* pUserData,
+ size_t size,
+ VkInternalAllocType allocType,
+ VkSystemAllocScope allocScope);
+
+typedef void (VKAPI *PFN_vkInternalFreeNotification)(
+ void* pUserData,
+ size_t size,
+ VkInternalAllocType allocType,
+ VkSystemAllocScope allocScope);
+
typedef void (VKAPI *PFN_vkVoidFunction)(void);
typedef struct {
@@ -1045,16 +1072,9 @@
} VkApplicationInfo;
typedef struct {
- void* pUserData;
- PFN_vkAllocFunction pfnAlloc;
- PFN_vkFreeFunction pfnFree;
-} VkAllocCallbacks;
-
-typedef struct {
VkStructureType sType;
const void* pNext;
const VkApplicationInfo* pAppInfo;
- const VkAllocCallbacks* pAllocCb;
uint32_t enabledLayerNameCount;
const char*const* ppEnabledLayerNames;
uint32_t enabledExtensionNameCount;
@@ -1062,6 +1082,15 @@
} VkInstanceCreateInfo;
typedef struct {
+ void* pUserData;
+ PFN_vkAllocFunction pfnAlloc;
+ PFN_vkReallocFunction pfnRealloc;
+ PFN_vkFreeFunction pfnFree;
+ PFN_vkInternalAllocNotification pfnInternalAlloc;
+ PFN_vkInternalFreeNotification pfnInternalFree;
+} VkAllocCallbacks;
+
+typedef struct {
VkBool32 robustBufferAccess;
VkBool32 fullDrawIndexUint32;
VkBool32 imageCubeArray;
@@ -2047,8 +2076,8 @@
} VkMemoryBarrier;
-typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
-typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
+typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance);
+typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
@@ -2058,8 +2087,8 @@
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);
-typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
+typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice);
+typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
@@ -2068,8 +2097,8 @@
typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
-typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
-typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
+typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
+typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
@@ -2084,60 +2113,60 @@
typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo);
-typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
-typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
+typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence);
+typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
-typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
-typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
-typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
-typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore);
+typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent);
+typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
-typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
-typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
+typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool);
+typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
-typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
-typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
-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_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer);
+typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView);
+typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage);
+typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator);
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);
-typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule);
-typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
-typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
-typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
+typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView);
+typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule);
+typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader);
+typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
-typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
-typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
-typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
-typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler);
-typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
-typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
-typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
-typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
+typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler);
+typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
-typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
-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_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator);
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_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool);
+typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers);
@@ -2192,10 +2221,12 @@
#ifdef VK_PROTOTYPES
VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance);
void VKAPI vkDestroyInstance(
- VkInstance instance);
+ VkInstance instance,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkEnumeratePhysicalDevices(
VkInstance instance,
@@ -2244,10 +2275,12 @@
VkResult VKAPI vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice);
void VKAPI vkDestroyDevice(
- VkDevice device);
+ VkDevice device,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkEnumerateInstanceExtensionProperties(
const char* pLayerName,
@@ -2290,11 +2323,13 @@
VkResult VKAPI vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo* pAllocInfo,
+ const VkAllocCallbacks* pAllocator,
VkDeviceMemory* pMem);
void VKAPI vkFreeMemory(
VkDevice device,
- VkDeviceMemory mem);
+ VkDeviceMemory mem,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkMapMemory(
VkDevice device,
@@ -2382,11 +2417,13 @@
VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFence* pFence);
void VKAPI vkDestroyFence(
VkDevice device,
- VkFence fence);
+ VkFence fence,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkResetFences(
VkDevice device,
@@ -2407,20 +2444,24 @@
VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSemaphore* pSemaphore);
void VKAPI vkDestroySemaphore(
VkDevice device,
- VkSemaphore semaphore);
+ VkSemaphore semaphore,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkEvent* pEvent);
void VKAPI vkDestroyEvent(
VkDevice device,
- VkEvent event);
+ VkEvent event,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkGetEventStatus(
VkDevice device,
@@ -2437,11 +2478,13 @@
VkResult VKAPI vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkQueryPool* pQueryPool);
void VKAPI vkDestroyQueryPool(
VkDevice device,
- VkQueryPool queryPool);
+ VkQueryPool queryPool,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkGetQueryPoolResults(
VkDevice device,
@@ -2456,29 +2499,35 @@
VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBuffer* pBuffer);
void VKAPI vkDestroyBuffer(
VkDevice device,
- VkBuffer buffer);
+ VkBuffer buffer,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBufferView* pView);
void VKAPI vkDestroyBufferView(
VkDevice device,
- VkBufferView bufferView);
+ VkBufferView bufferView,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImage* pImage);
void VKAPI vkDestroyImage(
VkDevice device,
- VkImage image);
+ VkImage image,
+ const VkAllocCallbacks* pAllocator);
void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
@@ -2489,38 +2538,46 @@
VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImageView* pView);
void VKAPI vkDestroyImageView(
VkDevice device,
- VkImageView imageView);
+ VkImageView imageView,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShaderModule* pShaderModule);
void VKAPI vkDestroyShaderModule(
VkDevice device,
- VkShaderModule shaderModule);
+ VkShaderModule shaderModule,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShader* pShader);
void VKAPI vkDestroyShader(
VkDevice device,
- VkShader shader);
+ VkShader shader,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineCache* pPipelineCache);
void VKAPI vkDestroyPipelineCache(
VkDevice device,
- VkPipelineCache pipelineCache);
+ VkPipelineCache pipelineCache,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkGetPipelineCacheData(
VkDevice device,
@@ -2539,6 +2596,7 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines);
VkResult VKAPI vkCreateComputePipelines(
@@ -2546,47 +2604,57 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines);
void VKAPI vkDestroyPipeline(
VkDevice device,
- VkPipeline pipeline);
+ VkPipeline pipeline,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout);
void VKAPI vkDestroyPipelineLayout(
VkDevice device,
- VkPipelineLayout pipelineLayout);
+ VkPipelineLayout pipelineLayout,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSampler* pSampler);
void VKAPI vkDestroySampler(
VkDevice device,
- VkSampler sampler);
+ VkSampler sampler,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout);
void VKAPI vkDestroyDescriptorSetLayout(
VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout);
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool);
void VKAPI vkDestroyDescriptorPool(
VkDevice device,
- VkDescriptorPool descriptorPool);
+ VkDescriptorPool descriptorPool,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkResetDescriptorPool(
VkDevice device,
@@ -2614,20 +2682,24 @@
VkResult VKAPI vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFramebuffer* pFramebuffer);
void VKAPI vkDestroyFramebuffer(
VkDevice device,
- VkFramebuffer framebuffer);
+ VkFramebuffer framebuffer,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkRenderPass* pRenderPass);
void VKAPI vkDestroyRenderPass(
VkDevice device,
- VkRenderPass renderPass);
+ VkRenderPass renderPass,
+ const VkAllocCallbacks* pAllocator);
void VKAPI vkGetRenderAreaGranularity(
VkDevice device,
@@ -2637,11 +2709,13 @@
VkResult VKAPI vkCreateCommandPool(
VkDevice device,
const VkCmdPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkCmdPool* pCmdPool);
void VKAPI vkDestroyCommandPool(
VkDevice device,
- VkCmdPool cmdPool);
+ VkCmdPool cmdPool,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI vkResetCommandPool(
VkDevice device,
diff --git a/layers/basic.cpp b/layers/basic.cpp
index 778a362..f416d5a 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -95,27 +95,27 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
{
printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu);
- VkResult result = device_dispatch_table(*pDevice)->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = device_dispatch_table(*pDevice)->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
printf("Completed wrapped vkCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice);
return result;
}
/* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
- device_dispatch_table(device)->DestroyDevice(device);
+ device_dispatch_table(device)->DestroyDevice(device, pAllocator);
destroy_device_dispatch_table(key);
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
- instance_dispatch_table(instance)->DestroyInstance(instance);
+ instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator);
destroy_instance_dispatch_table(key);
}
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index 1d686dd..eb21585 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -158,11 +158,11 @@
pCount, pProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table;
- VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
my_data->report_data = debug_report_create_instance(
@@ -178,12 +178,12 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
@@ -387,7 +387,7 @@
return skipCall;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
{
VkBool32 skipCall = VK_FALSE;
layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
@@ -420,7 +420,7 @@
return VK_ERROR_VALIDATION_FAILED;
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
- VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS) {
my_device_data->report_data = layer_debug_report_create_device(phy_dev_data->report_data, *pDevice);
createDeviceRegisterExtensions(pCreateInfo, *pDevice);
@@ -429,27 +429,27 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
// Free device lifetime allocations
dispatch_key key = get_dispatch_key(device);
layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
- my_device_data->device_dispatch_table->DestroyDevice(device);
+ my_device_data->device_dispatch_table->DestroyDevice(device, pAllocator);
tableDebugMarkerMap.erase(key);
delete my_device_data->device_dispatch_table;
layer_data_map.erase(key);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool)
{
// TODO : Verify that requested QueueFamilyIndex for this pool exists
- VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pCmdPool);
+ VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, cmdPool);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, cmdPool, pAllocator);
}
VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
@@ -490,6 +490,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImage *pImage)
{
VkBool32 skipCall = VK_FALSE;
@@ -536,7 +537,7 @@
totalSize, ImageFormatProperties.maxResourceSize);
}
if (VK_FALSE == skipCall) {
- result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+ result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
}
return result;
}
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index bbcc4b0..c823e98 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1565,11 +1565,11 @@
}
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1585,12 +1585,12 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
@@ -1625,10 +1625,10 @@
}
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = dev_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS) {
layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
dev_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
@@ -1638,7 +1638,7 @@
}
// prototype
static void deleteRenderPasses(layer_data*);
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data* dev_data = get_my_data_ptr(key, layer_data_map);
@@ -1655,7 +1655,7 @@
dev_data->bufferMap.clear();
loader_platform_thread_unlock_mutex(&globalLock);
- dev_data->device_dispatch_table->DestroyDevice(device);
+ dev_data->device_dispatch_table->DestroyDevice(device, pAllocator);
tableDebugMarkerMap.erase(key);
delete dev_data->device_dispatch_table;
layer_data_map.erase(key);
@@ -1757,97 +1757,97 @@
return VK_ERROR_VALIDATION_FAILED;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFence(device, fence);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFence(device, fence, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySemaphore(device, semaphore);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyEvent(device, event);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyEvent(device, event, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyQueryPool(device, queryPool);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyQueryPool(device, queryPool, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- dev_data->device_dispatch_table->DestroyBuffer(device, buffer);
+ dev_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
dev_data->bufferMap.erase(buffer);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- dev_data->device_dispatch_table->DestroyBufferView(device, bufferView);
+ dev_data->device_dispatch_table->DestroyBufferView(device, bufferView, pAllocator);
dev_data->bufferViewMap.erase(bufferView);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- dev_data->device_dispatch_table->DestroyImage(device, image);
+ dev_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
dev_data->imageMap.erase(image);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyImageView(device, imageView);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyImageView(device, imageView, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyShaderModule(device, shaderModule);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyShaderModule(device, shaderModule, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- dev_data->device_dispatch_table->DestroyShader(device, shader);
+ dev_data->device_dispatch_table->DestroyShader(device, shader, pAllocator);
dev_data->shaderStageMap.erase(shader);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipeline(device, pipeline);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipeline(device, pipeline, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipelineLayout(device, pipelineLayout);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySampler(device, sampler);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySampler(device, sampler, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorSetLayout(device, descriptorSetLayout);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorPool(device, descriptorPool);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorPool(device, descriptorPool, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
@@ -1857,22 +1857,22 @@
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFramebuffer(device, framebuffer);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFramebuffer(device, framebuffer, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyRenderPass(device, renderPass);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyRenderPass(device, renderPass, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pBuffer);
+ VkResult result = dev_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
// TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid
@@ -1882,10 +1882,10 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pView);
+ VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
dev_data->bufferViewMap[*pView] = unique_ptr<VkBufferViewCreateInfo>(new VkBufferViewCreateInfo(*pCreateInfo));
@@ -1894,10 +1894,10 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+ VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
dev_data->imageMap[*pImage] = unique_ptr<VkImageCreateInfo>(new VkImageCreateInfo(*pCreateInfo));
@@ -1906,10 +1906,10 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
+ VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
dev_data->imageViewMap[*pView] = unique_ptr<VkImageViewCreateInfo>(new VkImageViewCreateInfo(*pCreateInfo));
@@ -1921,10 +1921,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShader *pShader)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateShader(device, pCreateInfo, pShader);
+ VkResult result = dev_data->device_dispatch_table->CreateShader(device, pCreateInfo, pAllocator, pShader);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
@@ -1939,19 +1940,21 @@
VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+ VkResult result = dev_data->device_dispatch_table->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
return result;
}
void VKAPI vkDestroyPipelineCache(
VkDevice device,
- VkPipelineCache pipelineCache)
+ VkPipelineCache pipelineCache,
+ const VkAllocCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- dev_data->device_dispatch_table->DestroyPipelineCache(device, pipelineCache);
+ dev_data->device_dispatch_table->DestroyPipelineCache(device, pipelineCache, pAllocator);
}
VkResult VKAPI vkGetPipelineCacheData(
@@ -1976,7 +1979,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
{
VkResult result = VK_SUCCESS;
//TODO What to do with pipelineCache?
@@ -1996,7 +1999,7 @@
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- result = dev_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+ result = dev_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
loader_platform_thread_lock_mutex(&globalLock);
for (i=0; i<count; i++) {
pPipeNode[i]->pipeline = pPipelines[i];
@@ -2018,10 +2021,10 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pSampler);
+ VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
dev_data->sampleMap[*pSampler] = unique_ptr<SAMPLER_NODE>(new SAMPLER_NODE(pSampler, pCreateInfo));
@@ -2030,10 +2033,10 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ VkResult result = dev_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
if (VK_SUCCESS == result) {
LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
if (NULL == pNewNode) {
@@ -2079,10 +2082,10 @@
return result;
}
-VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
+VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+ VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
if (VK_SUCCESS == result) {
PIPELINE_LAYOUT_NODE plNode = dev_data->pipelineLayoutMap[*pPipelineLayout];
plNode.descriptorSetLayouts.resize(pCreateInfo->setLayoutCount);
@@ -2098,10 +2101,10 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+ VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
if (VK_SUCCESS == result) {
// Insert this pool into Global Pool LL at head
if (log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
@@ -3270,10 +3273,10 @@
dev_data->device_dispatch_table->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ VkResult result = dev_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
if (VK_SUCCESS == result) {
// Shadow create info and store in map
VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo);
@@ -3437,13 +3440,13 @@
return skip_call;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
if (validateDependencies(dev_data, device, pCreateInfo)) {
return VK_ERROR_VALIDATION_FAILED;
}
- VkResult result = dev_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pRenderPass);
+ VkResult result = dev_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
if (VK_SUCCESS == result) {
// Shadow create info and store in map
VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo);
diff --git a/layers/image.cpp b/layers/image.cpp
index 8ae7a12..c615109 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -112,11 +112,11 @@
return res;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
my_data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->enabledExtensionNameCount,
@@ -127,13 +127,13 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
@@ -148,11 +148,11 @@
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
{
layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
- VkResult result = device_data->device_dispatch_table->CreateDevice(physicalDevice, pCreateInfo, pDevice);
+ VkResult result = device_data->device_dispatch_table->CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
if(result == VK_SUCCESS)
{
device_data->report_data = layer_debug_report_create_device(instance_data->report_data, *pDevice);
@@ -162,11 +162,11 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
- my_data->device_dispatch_table->DestroyDevice(device);
+ my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
delete my_data->device_dispatch_table;
layer_data_map.erase(key);
}
@@ -240,7 +240,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
{
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -259,7 +259,7 @@
if (skipCall)
return VK_ERROR_VALIDATION_FAILED;
- VkResult result = device_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+ VkResult result = device_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
if(result == VK_SUCCESS) {
device_data->imageMap[*pImage] = IMAGE_STATE(pCreateInfo);
@@ -267,14 +267,14 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
{
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
device_data->imageMap.erase(image);
- device_data->device_dispatch_table->DestroyImage(device, image);
+ device_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = VK_FALSE;
@@ -346,12 +346,12 @@
if (skipCall)
return VK_ERROR_VALIDATION_FAILED;
- VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pRenderPass);
+ VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
{
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -454,7 +454,7 @@
if (skipCall)
return VK_ERROR_VALIDATION_FAILED;
- VkResult result = device_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
+ VkResult result = device_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
return result;
}
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index cd60627..c9ea469 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -925,13 +925,13 @@
}
// hook DestroyInstance to remove tableInstanceMap entry
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
@@ -952,11 +952,12 @@
VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
my_data->report_data = debug_report_create_instance(
@@ -993,11 +994,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice *pDevice)
{
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
VkLayerDispatchTable *pDeviceTable = my_device_data->device_dispatch_table;
- VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS) {
layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
@@ -1007,7 +1009,8 @@
}
VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
- VkDevice device)
+ VkDevice device,
+ const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
@@ -1042,7 +1045,7 @@
#endif
VkLayerDispatchTable *pDisp = my_device_data->device_dispatch_table;
if (VK_FALSE == skipCall) {
- pDisp->DestroyDevice(device);
+ pDisp->DestroyDevice(device, pAllocator);
}
delete my_device_data->device_dispatch_table;
layer_data_map.erase(key);
@@ -1195,10 +1198,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo *pAllocInfo,
+ const VkAllocCallbacks* pAllocator,
VkDeviceMemory *pMem)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->AllocMemory(device, pAllocInfo, pMem);
+ VkResult result = my_data->device_dispatch_table->AllocMemory(device, pAllocInfo, pAllocator, pMem);
// TODO : Track allocations and overall size here
loader_platform_thread_lock_mutex(&globalLock);
add_mem_obj_info(my_data, device, *pMem, pAllocInfo);
@@ -1209,7 +1213,8 @@
VK_LAYER_EXPORT void VKAPI vkFreeMemory(
VkDevice device,
- VkDeviceMemory mem)
+ VkDeviceMemory mem,
+ const VkAllocCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
/* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
@@ -1221,7 +1226,7 @@
print_mem_list(my_data, device);
printCBList(my_data, device);
loader_platform_thread_unlock_mutex(&globalLock);
- my_data->device_dispatch_table->FreeMemory(device, mem);
+ my_data->device_dispatch_table->FreeMemory(device, mem, pAllocator);
}
VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(
@@ -1260,7 +1265,7 @@
my_data->device_dispatch_table->UnmapMemory(device, mem);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
loader_platform_thread_lock_mutex(&globalLock);
@@ -1270,10 +1275,10 @@
my_data->fenceMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- my_data->device_dispatch_table->DestroyFence(device, fence);
+ my_data->device_dispatch_table->DestroyFence(device, fence, pAllocator);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = VK_FALSE;
@@ -1285,11 +1290,11 @@
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->DestroyBuffer(device, buffer);
+ my_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
}
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = VK_FALSE;
@@ -1301,7 +1306,7 @@
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->DestroyImage(device, image);
+ my_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
}
}
@@ -1429,10 +1434,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFence *pFence)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->CreateFence(device, pCreateInfo, pFence);
+ VkResult result = my_data->device_dispatch_table->CreateFence(device, pCreateInfo, pAllocator, pFence);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
MT_FENCE_INFO* pFI = &my_data->fenceMap[*pFence];
@@ -1568,10 +1574,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBuffer *pBuffer)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pBuffer);
+ VkResult result = my_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_create_info(my_data, (uint64_t)*pBuffer, VK_OBJECT_TYPE_BUFFER, pCreateInfo);
@@ -1583,10 +1590,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImage *pImage)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+ VkResult result = my_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_create_info(my_data, (uint64_t)*pImage, VK_OBJECT_TYPE_IMAGE, pCreateInfo);
@@ -1598,10 +1606,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImageView *pView)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
+ VkResult result = my_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
// Validate that img has correct usage flags set
@@ -1616,10 +1625,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBufferView *pView)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pView);
+ VkResult result = my_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
// In order to create a valid buffer view, the buffer must have been created with at least one of the
@@ -2431,10 +2441,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSemaphore *pSemaphore)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->CreateSemaphore(device, pCreateInfo, pSemaphore);
+ VkResult result = my_data->device_dispatch_table->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
loader_platform_thread_lock_mutex(&globalLock);
if (*pSemaphore != VK_NULL_HANDLE) {
my_data->semaphoreMap[*pSemaphore] = MEMTRACK_SEMAPHORE_STATE_UNSET;
@@ -2445,7 +2456,8 @@
VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(
VkDevice device,
- VkSemaphore semaphore)
+ VkSemaphore semaphore,
+ const VkAllocCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
loader_platform_thread_lock_mutex(&globalLock);
@@ -2454,7 +2466,7 @@
my_data->semaphoreMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- my_data->device_dispatch_table->DestroySemaphore(device, semaphore);
+ my_data->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator);
}
VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 1db6b6f..5234462 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -40,23 +40,23 @@
/******************************** Layer multi1 functions **************************/
/* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
dispatch_key key = get_dispatch_key(device);
printf("At start of multi1 layer vkDestroyDevice()\n");
- pDisp->DestroyDevice(device);
+ pDisp->DestroyDevice(device, pAllocator);
multi1_device_table_map.erase(key);
printf("Completed multi1 layer vkDestroyDevice()\n");
}
-VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
printf("At start of multi1 layer vkCreateSampler()\n");
- VkResult result = pDisp->CreateSampler(device, pCreateInfo, pSampler);
+ VkResult result = pDisp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
printf("Completed multi1 layer vkCreateSampler()\n");
return result;
}
@@ -66,12 +66,13 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
printf("At start of multi1 layer vkCreateGraphicsPipeline()\n");
- VkResult result = pDisp->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+ VkResult result = pDisp->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
printf("Completed multi1 layer vkCreateGraphicsPipeline()\n");
return result;
}
@@ -139,13 +140,13 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(multi2_instance_table_map, instance);
dispatch_key key = get_dispatch_key(instance);
printf("At start of wrapped multi2 vkDestroyInstance()\n");
- pDisp->DestroyInstance(instance);
+ pDisp->DestroyInstance(instance, pAllocator);
multi2_instance_table_map.erase(key);
printf("Completed multi2 layer vkDestroyInstance()\n");
}
diff --git a/layers/object_track.h b/layers/object_track.h
index 6969b6f..ed611e9 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -634,11 +634,12 @@
VkResult
explicit_CreateInstance(
const VkInstanceCreateInfo *pCreateInfo,
+ const VkAllocCallbacks * pAllocator,
VkInstance * pInstance)
{
VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, *pInstance);
- VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -673,12 +674,13 @@
explicit_CreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo *pCreateInfo,
+ const VkAllocCallbacks *pAllocator,
VkDevice *pDevice)
{
loader_platform_thread_lock_mutex(&objLock);
// VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, gpu);
VkLayerDispatchTable *pDeviceTable = get_dispatch_table(ObjectTracker_device_table_map, *pDevice);
- VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS) {
layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
//// VkLayerDispatchTable *pTable = get_dispatch_table(ObjectTracker_device_table_map, *pDevice);
@@ -872,13 +874,14 @@
void
explicit_FreeMemory(
VkDevice device,
- VkDeviceMemory mem)
+ VkDeviceMemory mem,
+ const VkAllocCallbacks* pAllocator)
{
loader_platform_thread_lock_mutex(&objLock);
validate_object(device, device);
loader_platform_thread_unlock_mutex(&objLock);
- get_dispatch_table(ObjectTracker_device_table_map, device)->FreeMemory(device, mem);
+ get_dispatch_table(ObjectTracker_device_table_map, device)->FreeMemory(device, mem, pAllocator);
loader_platform_thread_lock_mutex(&objLock);
destroy_obj(device, mem);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 359a8c2..638bce5 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1822,10 +1822,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, *pInstance);
- VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
layer_data *data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1839,12 +1840,13 @@
}
VK_LAYER_EXPORT void VKAPI vkDestroyInstance(
- VkInstance instance)
+ VkInstance instance,
+ const VkAllocCallbacks* pAllocator)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
- pTable->DestroyInstance(instance);
+ pTable->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -2085,6 +2087,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice)
{
/*
@@ -2095,7 +2098,7 @@
* object as the first parameter. We couldn't get here if it was wrong!
*/
VkLayerDispatchTable *pTable = get_dispatch_table(pc_device_table_map, *pDevice);
- VkResult result = pTable->CreateDevice(physicalDevice, pCreateInfo, pDevice);
+ VkResult result = pTable->CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
if(result == VK_SUCCESS)
{
layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
@@ -2107,7 +2110,8 @@
}
VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
- VkDevice device)
+ VkDevice device,
+ const VkAllocCallbacks* pAllocator)
{
layer_debug_report_destroy_device(device);
@@ -2116,7 +2120,7 @@
fprintf(stderr, "Device: %p, key: %p\n", device, key);
#endif
- get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device);
+ get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device, pAllocator);
pc_device_table_map.erase(key);
assert(pc_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
}
@@ -2291,11 +2295,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo* pAllocInfo,
+ const VkAllocCallbacks* pAllocator,
VkDeviceMemory* pMem)
{
PreAllocMemory(device, pAllocInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pMem);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pAllocator, pMem);
PostAllocMemory(device, pMem, result);
@@ -2870,11 +2875,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFence* pFence)
{
PreCreateFence(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pFence);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pAllocator, pFence);
PostCreateFence(device, pFence, result);
@@ -3039,11 +3045,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSemaphore* pSemaphore)
{
PreCreateSemaphore(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pSemaphore);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
PostCreateSemaphore(device, pSemaphore, result);
@@ -3090,11 +3097,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkEvent* pEvent)
{
PreCreateEvent(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pEvent);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
PostCreateEvent(device, pEvent, result);
@@ -3232,11 +3240,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkQueryPool* pQueryPool)
{
PreCreateQueryPool(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
PostCreateQueryPool(device, pQueryPool, result);
@@ -3340,11 +3349,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBuffer* pBuffer)
{
PreCreateBuffer(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
PostCreateBuffer(device, pBuffer, result);
@@ -3398,11 +3408,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkBufferView* pView)
{
PreCreateBufferView(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pAllocator, pView);
PostCreateBufferView(device, pView, result);
@@ -3480,11 +3491,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImage* pImage)
{
PreCreateImage(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImage(device, pCreateInfo, pAllocator, pImage);
PostCreateImage(device, pImage, result);
@@ -3618,11 +3630,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkImageView* pView)
{
PreCreateImageView(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImageView(device, pCreateInfo, pView);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImageView(device, pCreateInfo, pAllocator, pView);
PostCreateImageView(device, pView, result);
@@ -3670,10 +3683,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShaderModule* pShaderModule)
{
PreCreateShaderModule(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pShaderModule);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
PostCreateShaderModule(device, pShaderModule, result);
return result;
}
@@ -3721,11 +3735,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShader* pShader)
{
PreCreateShader(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShader(device, pCreateInfo, pShader);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShader(device, pCreateInfo, pAllocator, pShader);
PostCreateShader(device, pShader, result);
@@ -3775,11 +3790,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
PreCreatePipelineCache(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
PostCreatePipelineCache(device, pPipelineCache, result);
@@ -4176,11 +4192,12 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines)
{
PreCreateGraphicsPipelines(device, pCreateInfos);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
PostCreateGraphicsPipelines(device, pipelineCache, count, pPipelines, result);
@@ -4248,11 +4265,12 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines)
{
PreCreateComputePipelines(device, pCreateInfos);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
PostCreateComputePipelines(device, pipelineCache, count, pPipelines, result);
@@ -4305,11 +4323,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
PreCreatePipelineLayout(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
PostCreatePipelineLayout(device, pPipelineLayout, result);
@@ -4412,11 +4431,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkSampler* pSampler)
{
PreCreateSampler(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
PostCreateSampler(device, pSampler, result);
@@ -4476,11 +4496,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
PreCreateDescriptorSetLayout(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
PostCreateDescriptorSetLayout(device, pSetLayout, result);
@@ -4540,11 +4561,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
PreCreateDescriptorPool(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
PostCreateDescriptorPool(device, pCreateInfo->maxSets, pDescriptorPool, result);
@@ -4775,11 +4797,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFramebuffer* pFramebuffer)
{
PreCreateFramebuffer(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
PostCreateFramebuffer(device, pFramebuffer, result);
@@ -4956,11 +4979,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
PreCreateRenderPass(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
PostCreateRenderPass(device, pRenderPass, result);
@@ -5031,11 +5055,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
VkDevice device,
const VkCmdPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkCmdPool* pCmdPool)
{
PreCreateCommandPool(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pCmdPool);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
PostCreateCommandPool(device, pCmdPool, result);
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index eae5867..c53d776 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -207,7 +207,7 @@
// map image2
// read from image2's mapped memeory.
- err = pTableDevice->CreateImage(device, &imgCreateInfo, &image2);
+ err = pTableDevice->CreateImage(device, &imgCreateInfo, NULL, &image2);
assert(!err);
pTableDevice->GetImageMemoryRequirements(device, image2, &memRequirements);
@@ -222,7 +222,7 @@
&memAllocInfo.memoryTypeIndex);
assert(pass);
- err = pTableDevice->AllocMemory(device, &memAllocInfo, &mem2);
+ err = pTableDevice->AllocMemory(device, &memAllocInfo, NULL, &mem2);
assert(!err);
err = pTableQueue->BindImageMemory(device, image2, mem2, 0);
@@ -308,7 +308,7 @@
// Clean up
pTableDevice->UnmapMemory(device, mem2);
- pTableDevice->FreeMemory(device, mem2);
+ pTableDevice->FreeMemory(device, mem2, NULL);
pTableDevice->FreeCommandBuffers(device, deviceMap[device]->cmdPool, 1, &cmdBuffer);
}
@@ -336,10 +336,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice *pDevice)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(screenshot_device_table_map, *pDevice);
- VkResult result = pDisp->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = pDisp->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS) {
init_screenshot();
@@ -461,10 +462,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
VkDevice device,
const VkCmdPoolCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkCmdPool *pCmdPool)
{
VkLayerDispatchTable* pTable = screenshot_device_table_map[device];
- VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pCmdPool);
+ VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
loader_platform_thread_lock_mutex(&globalLock);
if (screenshotEnvQueried && screenshotFrames.empty()) {
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 53efcad..9e417f6 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -138,11 +138,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
/* stash a copy of the layout bindings */
- VkResult result = my_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ VkResult result = my_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
@@ -158,10 +159,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+ VkResult result = my_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
@@ -602,6 +604,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShaderModule *pShaderModule)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -613,7 +616,7 @@
return VK_ERROR_VALIDATION_FAILED;
}
- VkResult res = my_data->device_dispatch_table->CreateShaderModule(device, pCreateInfo, pShaderModule);
+ VkResult res = my_data->device_dispatch_table->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
if (res == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
@@ -626,10 +629,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkShader *pShader)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult res = my_data->device_dispatch_table->CreateShader(device, pCreateInfo, pShader);
+ VkResult res = my_data->device_dispatch_table->CreateShader(device, pCreateInfo, pAllocator, pShader);
loader_platform_thread_lock_mutex(&globalLock);
my_data->shader_object_map[*pShader] = new shader_object(my_data, pCreateInfo);
@@ -640,10 +644,11 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkRenderPass *pRenderPass)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult res = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pRenderPass);
+ VkResult res = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
loader_platform_thread_lock_mutex(&globalLock);
my_data->render_pass_map[*pRenderPass] = new render_pass(pCreateInfo);
@@ -1130,6 +1135,7 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo *pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline *pPipelines)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1142,7 +1148,7 @@
/* The driver is allowed to crash if passed junk. Only actually create the
* pipeline if we didn't run into any showstoppers above.
*/
- return my_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+ return my_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
}
else {
return VK_ERROR_VALIDATION_FAILED;
@@ -1150,10 +1156,10 @@
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
{
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
- VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS) {
layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
@@ -1162,22 +1168,23 @@
}
/* hook DextroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
- my_device_data->device_dispatch_table->DestroyDevice(device);
+ my_device_data->device_dispatch_table->DestroyDevice(device, pAllocator);
delete my_device_data->device_dispatch_table;
layer_data_map.erase(key);
}
VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1193,11 +1200,11 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
- my_data->instance_dispatch_table->DestroyInstance(instance);
+ my_data->instance_dispatch_table->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 42cf7a8..0075b6f 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -197,12 +197,12 @@
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
// Call down the call chain:
VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table;
- VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+ VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
// Since it succeeded, do layer-specific work:
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -218,7 +218,7 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
{
VkBool32 skipCall = VK_FALSE;
dispatch_key key = get_dispatch_key(instance);
@@ -233,7 +233,7 @@
if (VK_FALSE == skipCall) {
// Call down the call chain:
- my_data->instance_dispatch_table->DestroyInstance(instance);
+ my_data->instance_dispatch_table->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
@@ -299,7 +299,7 @@
return VK_ERROR_VALIDATION_FAILED;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
{
VkResult result = VK_SUCCESS;
VkBool32 skipCall = VK_FALSE;
@@ -319,7 +319,7 @@
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
// Call down the call chain:
result = my_device_data->device_dispatch_table->CreateDevice(
- physicalDevice, pCreateInfo, pDevice);
+ physicalDevice, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS) {
// Since it succeeded, do layer-specific work:
my_data->report_data = layer_debug_report_create_device(my_data->report_data, *pDevice);
@@ -329,7 +329,7 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
VkBool32 skipCall = VK_FALSE;
dispatch_key key = get_dispatch_key(device);
@@ -344,7 +344,7 @@
if (VK_FALSE == skipCall) {
// Call down the call chain:
- my_data->device_dispatch_table->DestroyDevice(device);
+ my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
}
// Regardless of skipCall value, do some internal cleanup:
diff --git a/loader/debug_report.c b/loader/debug_report.c
index d8d3450..c1cca4f 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -74,7 +74,7 @@
void* pUserData,
VkDbgMsgCallback* pMsgCallback)
{
- VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!pNewDbgFuncNode)
return VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/loader/loader.c b/loader/loader.c
index 6b06b31..53fdbf3 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -111,11 +111,11 @@
void* loader_heap_alloc(
const struct loader_instance *instance,
size_t size,
- VkSystemAllocType alloc_type)
+ VkSystemAllocScope alloc_scope)
{
if (instance && instance->alloc_callbacks.pfnAlloc) {
/* TODO: What should default alignment be? 1, 4, 8, other? */
- return instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_type);
+ return instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
}
return malloc(size);
}
@@ -137,10 +137,10 @@
void *pMem,
size_t orig_size,
size_t size,
- VkSystemAllocType alloc_type)
+ VkSystemAllocScope alloc_scope)
{
if (pMem == NULL || orig_size == 0)
- return loader_heap_alloc(instance, size, alloc_type);
+ return loader_heap_alloc(instance, size, alloc_scope);
if (size == 0) {
loader_heap_free(instance, pMem);
return NULL;
@@ -150,7 +150,7 @@
memset(((uint8_t *)pMem) + size, 0, orig_size - size);
return pMem;
}
- void *new_ptr = instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_type);
+ void *new_ptr = instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
if (!new_ptr)
return NULL;
memcpy(new_ptr, pMem, orig_size);
@@ -162,7 +162,7 @@
void *loader_tls_heap_alloc(size_t size)
{
- return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
}
void loader_tls_heap_free(void *pMem)
@@ -429,7 +429,7 @@
if (layer_list->capacity == 0) {
layer_list->list = loader_heap_alloc(inst,
sizeof(struct loader_layer_properties) * 64,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (layer_list->list == NULL) {
loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't add any layer properties to list");
return NULL;
@@ -444,7 +444,7 @@
layer_list->list = loader_heap_realloc(inst, layer_list->list,
layer_list->capacity,
layer_list->capacity * 2,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (layer_list->list == NULL) {
loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
"realloc failed for layer list");
@@ -575,7 +575,7 @@
struct loader_extension_list *ext_info)
{
ext_info->capacity = 32 * sizeof(VkExtensionProperties);
- ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (ext_info->list == NULL) {
return false;
}
@@ -629,7 +629,7 @@
ext_list->list,
ext_list->capacity,
ext_list->capacity * 2,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
// double capacity
ext_list->capacity *= 2;
}
@@ -676,7 +676,7 @@
struct loader_layer_list *list)
{
list->capacity = 32 * sizeof(struct loader_layer_properties);
- list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (list->list == NULL) {
return false;
}
@@ -700,7 +700,7 @@
struct loader_layer_library_list *list)
{
list->capacity = 32 * sizeof(struct loader_lib_info);
- list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (list->list == NULL) {
return false;
}
@@ -755,7 +755,7 @@
list->list,
list->capacity,
list->capacity * 2,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
// double capacity
list->capacity *= 2;
}
@@ -833,7 +833,7 @@
list->list,
list->capacity,
list->capacity * 2,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
// double capacity
list->capacity *= 2;
}
@@ -958,7 +958,7 @@
{
struct loader_device *new_dev;
- new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
if (!new_dev) {
loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc struct laoder-device");
return NULL;
@@ -1017,7 +1017,7 @@
{
struct loader_icd *icd;
- icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!icd)
return NULL;
@@ -1068,7 +1068,7 @@
{
loader_scanned_icd_clear(inst, icd_libs);
icd_libs->capacity = 8 * sizeof(struct loader_scanned_icds);
- icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
}
@@ -1113,7 +1113,7 @@
icd_libs->list,
icd_libs->capacity,
icd_libs->capacity * 2,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
// double capacity
icd_libs->capacity *= 2;
}
@@ -1126,7 +1126,7 @@
new_node->lib_name = (char *) loader_heap_alloc(inst,
strlen(filename) + 1,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!new_node->lib_name) {
loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Out of memory can't add icd");
return;
@@ -1376,7 +1376,7 @@
inst,
sizeof(VkExtensionProperties) *
src->instance_extension_list.count,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) *
src->instance_extension_list.count;
memcpy(dst->instance_extension_list.list, src->instance_extension_list.list,
@@ -1385,7 +1385,7 @@
inst,
sizeof(VkExtensionProperties) *
src->device_extension_list.count,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
dst->device_extension_list.capacity = sizeof(VkExtensionProperties) *
src->device_extension_list.count;
memcpy(dst->device_extension_list.list, src->device_extension_list.list,
@@ -1759,14 +1759,14 @@
if (out_files->count == 0) {
out_files->filename_list = loader_heap_alloc(inst,
alloced_count * sizeof(char *),
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
}
else if (out_files->count == alloced_count) {
out_files->filename_list = loader_heap_realloc(inst,
out_files->filename_list,
alloced_count * sizeof(char *),
alloced_count * sizeof(char *) * 2,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
alloced_count *= 2;
}
if (out_files->filename_list == NULL) {
@@ -1776,7 +1776,7 @@
out_files->filename_list[out_files->count] = loader_heap_alloc(
inst,
strlen(name) + 1,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
if (out_files->filename_list[out_files->count] == NULL) {
loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
return;
@@ -2073,7 +2073,7 @@
inst, loader.loaded_layer_lib_list,
loader.loaded_layer_lib_capacity,
new_alloc_size,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!new_layer_lib_list) {
loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: realloc failed in loader_add_layer_lib");
return NULL;
@@ -2135,7 +2135,7 @@
/* Need to remove unused library from list */
new_layer_lib_list = loader_heap_alloc(inst,
loader.loaded_layer_lib_capacity,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!new_layer_lib_list) {
loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: heap alloc failed loader_remove_layer_library");
return;
@@ -2415,6 +2415,7 @@
static VkResult VKAPI scratch_vkCreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo *pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice *pDevice)
{
return VK_SUCCESS;
@@ -2456,7 +2457,7 @@
wrappedGpus = loader_heap_alloc(inst,
sizeof (VkBaseLayerObject) * dev->activated_layer_list.count,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!wrappedGpus) {
loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer");
return 0;
@@ -2612,6 +2613,7 @@
VkResult VKAPI loader_CreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
struct loader_instance *ptr_instance = *(struct loader_instance **) pInstance;
@@ -2625,7 +2627,6 @@
icd_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
icd_create_info.enabledLayerNameCount = 0;
icd_create_info.ppEnabledLayerNames = NULL;
- icd_create_info.pAllocCb = pCreateInfo->pAllocCb;
icd_create_info.pAppInfo = pCreateInfo->pAppInfo;
icd_create_info.pNext = pCreateInfo->pNext;
@@ -2656,6 +2657,7 @@
}
res = ptr_instance->icd_libs.list[i].CreateInstance(&icd_create_info,
+ pAllocator,
&(icd->instance));
success = loader_icd_init_entrys(
icd,
@@ -2690,7 +2692,8 @@
}
void VKAPI loader_DestroyInstance(
- VkInstance instance)
+ VkInstance instance,
+ const VkAllocCallbacks* pAllocator)
{
struct loader_instance *ptr_instance = loader_instance(instance);
struct loader_icd *icds = ptr_instance->icds;
@@ -2714,7 +2717,7 @@
while (icds) {
if (icds->instance) {
- icds->DestroyInstance(icds->instance);
+ icds->DestroyInstance(icds->instance, pAllocator);
}
next_icd = icds->next;
icds->instance = VK_NULL_HANDLE;
@@ -2754,7 +2757,7 @@
icd->gpus = (VkPhysicalDevice *) loader_heap_alloc(
ptr_instance,
n * sizeof(VkPhysicalDevice),
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!icd->gpus) {
/* TODO: Add cleanup code here */
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -2927,6 +2930,7 @@
VkResult VKAPI loader_CreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice)
{
uint32_t gpu_index;
@@ -2997,7 +3001,7 @@
// since gpu object maybe wrapped by a layer need to get unwrapped version
// we haven't yet called down the chain for the layer to unwrap the object
- res = icd->CreateDevice(icd->gpus[gpu_index], pCreateInfo, pDevice);
+ res = icd->CreateDevice(icd->gpus[gpu_index], pCreateInfo, pAllocator, pDevice);
if (res != VK_SUCCESS) {
return res;
}
@@ -3021,7 +3025,7 @@
}
loader_activate_device_layers(inst, dev, *pDevice);
- res = dev->loader_dispatch.CreateDevice(gpu, pCreateInfo, pDevice);
+ res = dev->loader_dispatch.CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
dev->loader_dispatch.CreateDevice = icd->CreateDevice;
diff --git a/loader/loader.h b/loader/loader.h
index 3e4ce1b..96dd277 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -265,10 +265,12 @@
/* instance layer chain termination entrypoint definitions */
VkResult VKAPI loader_CreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance);
void VKAPI loader_DestroyInstance(
- VkInstance instance);
+ VkInstance instance,
+ const VkAllocCallbacks* pAllocator);
VkResult VKAPI loader_EnumeratePhysicalDevices(
VkInstance instance,
@@ -326,6 +328,7 @@
VkResult VKAPI loader_CreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice);
/* helper function definitions */
@@ -390,7 +393,7 @@
void* loader_heap_alloc(
const struct loader_instance *instance,
size_t size,
- VkSystemAllocType allocType);
+ VkSystemAllocScope allocScope);
void loader_heap_free(
const struct loader_instance *instance,
diff --git a/loader/trampoline.c b/loader/trampoline.c
index a73e922..219827c 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -34,6 +34,7 @@
/* Trampoline entrypoints */
LOADER_EXPORT VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
struct loader_instance *ptr_instance = NULL;
@@ -41,14 +42,12 @@
loader_platform_thread_once(&once_init, loader_initialize);
- if (pCreateInfo->pAllocCb
- && pCreateInfo->pAllocCb->pfnAlloc
- && pCreateInfo->pAllocCb->pfnFree) {
- ptr_instance = (struct loader_instance *) pCreateInfo->pAllocCb->pfnAlloc(
- pCreateInfo->pAllocCb->pUserData,
+ if (pAllocator) {
+ ptr_instance = (struct loader_instance *) pAllocator->pfnAlloc(
+ pAllocator->pUserData,
sizeof(struct loader_instance),
sizeof(VkInstance),
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
} else {
ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance));
}
@@ -60,12 +59,8 @@
loader_platform_thread_lock_mutex(&loader_lock);
memset(ptr_instance, 0, sizeof(struct loader_instance));
- if (pCreateInfo->pAllocCb
- && pCreateInfo->pAllocCb->pfnAlloc
- && pCreateInfo->pAllocCb->pfnFree) {
- ptr_instance->alloc_callbacks.pUserData = pCreateInfo->pAllocCb->pUserData;
- ptr_instance->alloc_callbacks.pfnAlloc = pCreateInfo->pAllocCb->pfnAlloc;
- ptr_instance->alloc_callbacks.pfnFree = pCreateInfo->pAllocCb->pfnFree;
+ if (pAllocator) {
+ ptr_instance->alloc_callbacks = *pAllocator;
}
/* Due to implicit layers need to get layer list even if
@@ -116,7 +111,7 @@
ptr_instance->disp = loader_heap_alloc(
ptr_instance,
sizeof(VkLayerInstanceDispatchTable),
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (ptr_instance->disp == NULL) {
loader_delete_layer_properties(ptr_instance,
&ptr_instance->device_layer_list);
@@ -161,7 +156,7 @@
*pInstance = (VkInstance) ptr_instance;
- res = ptr_instance->disp->CreateInstance(pCreateInfo, pInstance);
+ res = ptr_instance->disp->CreateInstance(pCreateInfo, pAllocator, pInstance);
/*
* Finally have the layers in place and everyone has seen
@@ -176,7 +171,8 @@
}
LOADER_EXPORT void VKAPI vkDestroyInstance(
- VkInstance instance)
+ VkInstance instance,
+ const VkAllocCallbacks* pAllocator)
{
const VkLayerInstanceDispatchTable *disp;
struct loader_instance *ptr_instance = NULL;
@@ -185,7 +181,7 @@
loader_platform_thread_lock_mutex(&loader_lock);
ptr_instance = loader_get_instance(instance);
- disp->DestroyInstance(instance);
+ disp->DestroyInstance(instance, pAllocator);
loader_deactivate_instance_layers(ptr_instance);
loader_heap_free(ptr_instance, ptr_instance->disp);
@@ -277,19 +273,20 @@
LOADER_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice)
{
VkResult res;
loader_platform_thread_lock_mutex(&loader_lock);
- res = loader_CreateDevice(gpu, pCreateInfo, pDevice);
+ res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
}
-LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
struct loader_device *dev;
@@ -298,7 +295,7 @@
disp = loader_get_dispatch(device);
loader_platform_thread_lock_mutex(&loader_lock);
- disp->DestroyDevice(device);
+ disp->DestroyDevice(device, pAllocator);
loader_remove_logical_device(inst, device);
loader_platform_thread_unlock_mutex(&loader_lock);
}
@@ -369,22 +366,22 @@
return disp->DeviceWaitIdle(device);
}
-LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem)
+LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->AllocMemory(device, pAllocInfo, pMem);
+ return disp->AllocMemory(device, pAllocInfo, pAllocator, pMem);
}
-LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
+LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->FreeMemory(device, mem);
+ disp->FreeMemory(device, mem, pAllocator);
}
LOADER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData)
@@ -513,22 +510,22 @@
return disp->QueueBindSparseImageMemory(queue, image, bindInfoCount, pBindInfo);
}
-LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
+LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateFence(device, pCreateInfo, pFence);
+ return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
}
-LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyFence(device, fence);
+ disp->DestroyFence(device, fence, pAllocator);
}
LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
@@ -558,40 +555,40 @@
return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
}
-LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore)
+LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateSemaphore(device, pCreateInfo, pSemaphore);
+ return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
}
-LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroySemaphore(device, semaphore);
+ disp->DestroySemaphore(device, semaphore, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent)
+LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateEvent(device, pCreateInfo, pEvent);
+ return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
}
-LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyEvent(device, event);
+ disp->DestroyEvent(device, event, pAllocator);
}
LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event)
@@ -621,22 +618,22 @@
return disp->ResetEvent(device, event);
}
-LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool)
+LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateQueryPool(device, pCreateInfo, pQueryPool);
+ return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
}
-LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyQueryPool(device, queryPool);
+ disp->DestroyQueryPool(device, queryPool, pAllocator);
}
LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
@@ -648,58 +645,58 @@
return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags);
}
-LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
+LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateBuffer(device, pCreateInfo, pBuffer);
+ return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
}
-LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyBuffer(device, buffer);
+ disp->DestroyBuffer(device, buffer, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
+LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateBufferView(device, pCreateInfo, pView);
+ return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
}
-LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyBufferView(device, bufferView);
+ disp->DestroyBufferView(device, bufferView, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateImage(device, pCreateInfo, pImage);
+ return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
}
-LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyImage(device, image);
+ disp->DestroyImage(device, image, pAllocator);
}
LOADER_EXPORT void VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
@@ -711,76 +708,76 @@
disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
}
-LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateImageView(device, pCreateInfo, pView);
+ return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
}
-LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyImageView(device, imageView);
+ disp->DestroyImageView(device, imageView, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader)
+LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShader)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateShaderModule(device, pCreateInfo, pShader);
+ return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
}
-LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyShaderModule(device, shaderModule);
+ disp->DestroyShaderModule(device, shaderModule, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
+LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateShader(device, pCreateInfo, pShader);
+ return disp->CreateShader(device, pCreateInfo, pAllocator, pShader);
}
-LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyShader(device, shader);
+ disp->DestroyShader(device, shader, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache)
+LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+ return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
}
-LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache)
+LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyPipelineCache(device, pipelineCache);
+ disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
}
LOADER_EXPORT VkResult VKAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
@@ -801,104 +798,104 @@
return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
}
-LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+ return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
-LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+ return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
-LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyPipeline(device, pipeline);
+ disp->DestroyPipeline(device, pipeline, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
+LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+ return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
}
-LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyPipelineLayout(device, pipelineLayout);
+ disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateSampler(device, pCreateInfo, pSampler);
+ return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
}
-LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroySampler(device, sampler);
+ disp->DestroySampler(device, sampler, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
}
-LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyDescriptorSetLayout(device, descriptorSetLayout);
+ disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+ return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
}
-LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyDescriptorPool(device, descriptorPool);
+ disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
}
@@ -938,40 +935,40 @@
disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
}
-LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
+LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
}
-LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyFramebuffer(device, framebuffer);
+ disp->DestroyFramebuffer(device, framebuffer, pAllocator);
}
-LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
+LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
+ return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
}
-LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyRenderPass(device, renderPass);
+ disp->DestroyRenderPass(device, renderPass, pAllocator);
}
LOADER_EXPORT void VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
@@ -983,22 +980,22 @@
disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
}
-LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
+LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateCommandPool(device, pCreateInfo, pCmdPool);
+ return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
}
-LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
+LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- disp->DestroyCommandPool(device, cmdPool);
+ disp->DestroyCommandPool(device, cmdPool, pAllocator);
}
LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index a1abc8c..d1e61e7 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -764,7 +764,7 @@
memset(&event_info, 0, sizeof(event_info));
event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
- err = vkCreateEvent(dev_.handle(), &event_info, &event);
+ err = vkCreateEvent(dev_.handle(), &event_info, NULL, &event);
ASSERT_VK_SUCCESS(err);
err = vkResetEvent(dev_.handle(), event);
@@ -821,7 +821,7 @@
EXPECT_EQ(0x11111111, data[0]);
bufs[2].memory().unmap();
- vkDestroyEvent(dev_.handle(), event);
+ vkDestroyEvent(dev_.handle(), event, NULL);
}
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 37b72e2..34afc93 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -97,12 +97,11 @@
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_info;
- inst_info.pAllocCb = NULL;
inst_info.enabledLayerNameCount = 0;
inst_info.ppEnabledLayerNames = NULL;
inst_info.enabledExtensionNameCount = 0;
inst_info.ppEnabledExtensionNames = NULL;
- err = vkCreateInstance(&inst_info, &this->inst);
+ err = vkCreateInstance(&inst_info, NULL, &this->inst);
ASSERT_VK_SUCCESS(err);
err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, NULL);
ASSERT_VK_SUCCESS(err);
@@ -117,7 +116,7 @@
virtual void TearDown() {
delete this->m_device;
- vkDestroyInstance(this->inst);
+ vkDestroyInstance(this->inst, NULL);
}
};
@@ -212,7 +211,7 @@
// VkDevice device,
// const VkImageCreateInfo* pCreateInfo,
// VkImage* pImage);
- err = vkCreateImage(device(), &imageCreateInfo, &m_image);
+ err = vkCreateImage(device(), &imageCreateInfo, NULL, &m_image);
ASSERT_VK_SUCCESS(err);
VkMemoryRequirements mem_req;
@@ -231,7 +230,7 @@
ASSERT_TRUE(pass);
/* allocate memory */
- err = vkAllocMemory(device(), &mem_info, &m_image_mem);
+ err = vkAllocMemory(device(), &mem_info, NULL, &m_image_mem);
ASSERT_VK_SUCCESS(err);
/* bind memory */
@@ -242,8 +241,8 @@
void VkImageTest::DestroyImage()
{
// All done with image object and memory, clean up
- vkDestroyImage(device(), m_image);
- vkFreeMemory(device(), m_image_mem);
+ vkDestroyImage(device(), m_image, NULL);
+ vkFreeMemory(device(), m_image_mem, NULL);
}
void VkImageTest::CreateImageView(VkImageViewCreateInfo *pCreateInfo,
@@ -251,13 +250,13 @@
{
VkResult err;
pCreateInfo->image = this->m_image;
- err = vkCreateImageView(device(), pCreateInfo, pView);
+ err = vkCreateImageView(device(), pCreateInfo, NULL, pView);
ASSERT_VK_SUCCESS(err);
}
void VkImageTest::DestroyImageView(VkImageView imageView)
{
- vkDestroyImageView(device(), imageView);
+ vkDestroyImageView(device(), imageView, NULL);
}
TEST_F(VkImageTest, CreateImageViewTest) {
diff --git a/tests/init.cpp b/tests/init.cpp
index 0eb32f1..bbb63cc 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -103,12 +103,11 @@
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_info;
- inst_info.pAllocCb = NULL;
inst_info.enabledLayerNameCount = 0;
inst_info.ppEnabledLayerNames = NULL;
inst_info.enabledExtensionNameCount = 0;
inst_info.ppEnabledExtensionNames = NULL;
- err = vkCreateInstance(&inst_info, &inst);
+ err = vkCreateInstance(&inst_info, NULL, &inst);
ASSERT_VK_SUCCESS(err);
err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
ASSERT_VK_SUCCESS(err);
@@ -135,7 +134,7 @@
virtual void TearDown() {
delete m_device;
- vkDestroyInstance(inst);
+ vkDestroyInstance(inst, NULL);
}
};
@@ -156,7 +155,7 @@
pass = m_device->phy().set_memory_type(((1 << mem_props.memoryTypeCount) - 1), &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
ASSERT_TRUE(pass);
- err = vkAllocMemory(device(), &alloc_info, &gpu_mem);
+ err = vkAllocMemory(device(), &alloc_info, NULL, &gpu_mem);
ASSERT_VK_SUCCESS(err);
err = vkMapMemory(device(), gpu_mem, 0, 0, 0, (void **) &pData);
@@ -167,7 +166,7 @@
vkUnmapMemory(device(), gpu_mem);
- vkFreeMemory(device(), gpu_mem);
+ vkFreeMemory(device(), gpu_mem, NULL);
}
TEST_F(VkTest, Event) {
@@ -184,7 +183,7 @@
memset(&event_info, 0, sizeof(event_info));
event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
- err = vkCreateEvent(device(), &event_info, &event);
+ err = vkCreateEvent(device(), &event_info, NULL, &event);
ASSERT_VK_SUCCESS(err);
err = vkResetEvent(device(), event);
@@ -202,7 +201,7 @@
// TODO: Test actual synchronization with command buffer event.
// All done with event memory, clean up
- vkDestroyEvent(device(), event);
+ vkDestroyEvent(device(), event, NULL);
}
#define MAX_QUERY_SLOTS 10
@@ -243,7 +242,7 @@
// const VkQueryPoolCreateInfo* pCreateInfo,
// VkQueryPool* pQueryPool);
- err = vkCreateQueryPool(device(), &query_info, &query_pool);
+ err = vkCreateQueryPool(device(), &query_info, NULL, &query_pool);
ASSERT_VK_SUCCESS(err);
// TODO: Test actual synchronization with command buffer event.
@@ -265,7 +264,7 @@
}
- vkDestroyQueryPool(device(), query_pool);
+ vkDestroyQueryPool(device(), query_pool, NULL);
}
void getQueue(vk_testing::Device *device, uint32_t queue_node_index, const char *qname)
@@ -357,7 +356,7 @@
// VkDevice device,
// const VkImageCreateInfo* pCreateInfo,
// VkImage* pImage);
- err = vkCreateImage(device(), &imageCreateInfo, &image);
+ err = vkCreateImage(device(), &imageCreateInfo, NULL, &image);
ASSERT_VK_SUCCESS(err);
// Verify image resources
@@ -423,7 +422,7 @@
pass = m_device->phy().set_memory_type(mem_req.memoryTypeBits, &mem_info, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(device(), &mem_info, &image_mem);
+ err = vkAllocMemory(device(), &mem_info, NULL, &image_mem);
ASSERT_VK_SUCCESS(err);
err = vkBindImageMemory(device(), image, image_mem, 0);
@@ -464,17 +463,17 @@
// const VkImageViewCreateInfo* pCreateInfo,
// VkImageView* pView);
- err = vkCreateImageView(device(), &viewInfo, &view);
+ err = vkCreateImageView(device(), &viewInfo, NULL, &view);
ASSERT_VK_SUCCESS(err) << "vkCreateImageView failed";
// TODO: Test image memory.
// All done with image memory, clean up
- vkDestroyImageView(device(), view);
- vkDestroyImage(device(), image);
+ vkDestroyImageView(device(), view, NULL);
+ vkDestroyImage(device(), image, NULL);
if (mem_req.size) {
- vkFreeMemory(device(), image_mem);
+ vkFreeMemory(device(), image_mem, NULL);
}
}
@@ -502,7 +501,7 @@
cmd_pool_info.pNext = NULL,
cmd_pool_info.queueFamilyIndex = graphics_queue_node_index;
cmd_pool_info.flags = 0,
- err = vkCreateCommandPool(device(), &cmd_pool_info, &cmdPool);
+ err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &cmdPool);
ASSERT_VK_SUCCESS(err) << "vkCreateCommandPool failed";
info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
@@ -513,7 +512,7 @@
ASSERT_VK_SUCCESS(err) << "vkAllocCommandBuffers failed";
vkFreeCommandBuffers(device(), cmdPool, 1, &cmdBuffer);
- vkDestroyCommandPool(device(), cmdPool);
+ vkDestroyCommandPool(device(), cmdPool, NULL);
}
TEST_F(VkTest, TestCommandBuffer) {
@@ -548,7 +547,7 @@
moduleCreateInfo.pCode = code;
moduleCreateInfo.codeSize = codeSize;
moduleCreateInfo.flags = 0;
- err = vkCreateShaderModule(device(), &moduleCreateInfo, &module);
+ err = vkCreateShaderModule(device(), &moduleCreateInfo, NULL, &module);
ASSERT_VK_SUCCESS(err);
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
@@ -557,10 +556,10 @@
createInfo.pName = "main";
createInfo.flags = 0;
createInfo.stage = stage;
- err = vkCreateShader(device(), &createInfo, &shader);
+ err = vkCreateShader(device(), &createInfo, NULL, &shader);
ASSERT_VK_SUCCESS(err);
- vkDestroyShaderModule(device(), module);
+ vkDestroyShaderModule(device(), module, NULL);
*pshader = shader;
}
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index f6fb2ab..81d77f8 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -533,7 +533,7 @@
// Introduce failure, do NOT set memProps to VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
mem_alloc.memoryTypeIndex = 1;
- err = vkCreateImage(m_device->device(), &image_create_info, &image);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(),
@@ -544,12 +544,12 @@
pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
if(!pass) { // If we can't find any unmappable memory this test doesn't make sense
- vkDestroyImage(m_device->device(), image);
+ vkDestroyImage(m_device->device(), image, NULL);
return;
}
// allocate memory
- err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+ err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
ASSERT_VK_SUCCESS(err);
// Try to bind free memory that has been freed
@@ -566,7 +566,7 @@
FAIL() << "Error received did not match expected error message from vkMapMemory in MemTracker";
}
- vkDestroyImage(m_device->device(), image);
+ vkDestroyImage(m_device->device(), image, NULL);
}
// TODO : Is this test still valid. Not sure it is with updates to memory binding model
@@ -609,7 +609,7 @@
// .memoryTypeIndex = 0,
// };
//
-// err = vkCreateImage(m_device->device(), &image_create_info, &image);
+// err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
// ASSERT_VK_SUCCESS(err);
//
// err = vkGetImageMemoryRequirements(m_device->device(),
@@ -623,7 +623,7 @@
// ASSERT_VK_SUCCESS(err);
//
// // allocate memory
-// err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+// err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
// ASSERT_VK_SUCCESS(err);
//
// // Bind memory to Image object
@@ -631,7 +631,7 @@
// ASSERT_VK_SUCCESS(err);
//
// // Introduce validation failure, free memory while still bound to object
-// vkFreeMemory(m_device->device(), mem);
+// vkFreeMemory(m_device->device(), mem, NULL);
// msgFlags = m_errorMonitor->GetState(&msgString);
//
// ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an warning while tring to free bound memory";
@@ -683,7 +683,7 @@
// Introduce failure, do NOT set memProps to VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
mem_alloc.memoryTypeIndex = 1;
- err = vkCreateImage(m_device->device(), &image_create_info, &image);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(),
@@ -695,9 +695,9 @@
ASSERT_TRUE(pass);
// allocate 2 memory objects
- err = vkAllocMemory(m_device->device(), &mem_alloc, &mem1);
+ err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem1);
ASSERT_VK_SUCCESS(err);
- err = vkAllocMemory(m_device->device(), &mem_alloc, &mem2);
+ err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem2);
ASSERT_VK_SUCCESS(err);
// Bind first memory object to Image object
@@ -713,9 +713,9 @@
FAIL() << "Error received did not match expected message when rebinding memory to an object";
}
- vkDestroyImage(m_device->device(), image);
- vkFreeMemory(m_device->device(), mem1);
- vkFreeMemory(m_device->device(), mem2);
+ vkDestroyImage(m_device->device(), image, NULL);
+ vkFreeMemory(m_device->device(), mem1, NULL);
+ vkFreeMemory(m_device->device(), mem2, NULL);
}
TEST_F(VkLayerTest, SubmitSignaledFence)
@@ -816,7 +816,7 @@
};
VkImage dsi;
- vkCreateImage(m_device->device(), &ici, &dsi);
+ vkCreateImage(m_device->device(), &ici, NULL, &dsi);
VkDepthStencilView dsv;
const VkDepthStencilViewCreateInfo dsvci = {
.sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO,
@@ -827,7 +827,7 @@
.arraySize = 1,
.flags = 0,
};
- vkCreateDepthStencilView(m_device->device(), &dsvci, &dsv);
+ vkCreateDepthStencilView(m_device->device(), &dsvci, NULL, &dsv);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after attempting to create DSView w/ image lacking USAGE_DS_BIT flag";
if (!strstr(msgString.c_str(),"Invalid usage flag for image ")) {
@@ -860,7 +860,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -876,7 +876,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -895,7 +895,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkPipeline badPipeline = (VkPipeline)0xbaadb1be;
@@ -909,9 +909,9 @@
FAIL() << "Error received was not 'Invalid VkPipeline Object 0xbaadb1be' but instead it was '" << msgString.c_str() << "'";
}
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, BindInvalidMemory)
@@ -954,7 +954,7 @@
mem_alloc.allocationSize = 0;
mem_alloc.memoryTypeIndex = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &image);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(),
@@ -967,11 +967,11 @@
ASSERT_TRUE(pass);
// allocate memory
- err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+ err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
ASSERT_VK_SUCCESS(err);
// Introduce validation failure, free memory before binding
- vkFreeMemory(m_device->device(), mem);
+ vkFreeMemory(m_device->device(), mem, NULL);
// Try to bind free memory that has been freed
err = vkBindImageMemory(m_device->device(), image, mem, 0);
@@ -984,7 +984,7 @@
FAIL() << "Error received from BindInvalidMemory was not 'Invalid VkDeviceMemory Object 0x<handle>' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), image);
+ vkDestroyImage(m_device->device(), image, NULL);
}
TEST_F(VkLayerTest, BindMemoryToDestroyedObject)
@@ -1027,7 +1027,7 @@
mem_alloc.allocationSize = 0;
mem_alloc.memoryTypeIndex = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &image);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(),
@@ -1039,11 +1039,11 @@
ASSERT_TRUE(pass);
// Allocate memory
- err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+ err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
ASSERT_VK_SUCCESS(err);
// Introduce validation failure, destroy Image object before binding
- vkDestroyImage(m_device->device(), image);
+ vkDestroyImage(m_device->device(), image, NULL);
ASSERT_VK_SUCCESS(err);
// Now Try to bind memory to this destroyed object
@@ -1057,7 +1057,7 @@
FAIL() << "Error received from BindMemoryToDestroyedObject was not 'Invalid VkImage Object 0x<handle>' but rather '" << msgString.c_str() << "'";
}
- vkFreeMemory(m_device->device(), mem);
+ vkFreeMemory(m_device->device(), mem, NULL);
}
TEST_F(VkLayerTest, InvalidBufferViewObject)
@@ -1081,7 +1081,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1096,7 +1096,7 @@
ds_layout_ci.bindingCount = 1;
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -1127,8 +1127,8 @@
FAIL() << "Error received was not 'Invalid VkBufferView Object 0xbaadbeef' but instead '" << msgString.c_str() << "'";
}
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
#endif // OBJ_TRACKER_TESTS
@@ -1354,7 +1354,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1370,7 +1370,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -1396,7 +1396,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -1424,9 +1424,9 @@
FAIL() << "Error received was not 'Incorrectly binding graphics pipeline (0x<handle>) without an active RenderPass' but rather '" << msgString.c_str() << "'";
}
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, AllocDescriptorFromEmptyPool)
@@ -1454,7 +1454,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1470,7 +1470,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -1487,8 +1487,8 @@
FAIL() << "Error received was not 'Unable to allocate 1 descriptors of type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER...' but rather '" << msgString.c_str() << "'";
}
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, FreeDescriptorFromOneShotPool)
@@ -1516,7 +1516,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1532,7 +1532,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -1552,8 +1552,8 @@
FAIL() << "Error received was not 'It is invalid to call vkFreeDescriptorSets() with a pool created with...' but instead it was '" << msgString.c_str() << "'";
}
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, InvalidDescriptorPool)
@@ -1632,7 +1632,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1647,7 +1647,7 @@
ds_layout_ci.bindingCount = 1;
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -1666,7 +1666,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -1688,9 +1688,9 @@
FAIL() << "Error received was not 'DS <blah> bound but it was never updated. You may want to either update it or not bind it.'";
}
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, NoBeginCmdBuffer)
@@ -1800,7 +1800,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1816,7 +1816,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -1834,7 +1834,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkViewport vp = {}; // Just need dummy vp to point to
@@ -1863,9 +1863,9 @@
VkPipeline pipeline;
VkPipelineCache pipelineCache;
- err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+ err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
ASSERT_VK_SUCCESS(err);
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o VS.";
@@ -1873,10 +1873,10 @@
FAIL() << "Error received was not 'Invalid Pipeline CreateInfo State: Vtx Shader required'";
}
- vkDestroyPipelineCache(m_device->device(), pipelineCache);
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
/*// TODO : This test should be good, but needs Tess support in compiler to run
TEST_F(VkLayerTest, InvalidPatchControlPoints)
@@ -1901,7 +1901,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), VK_DESCRIPTOR_POOL_USAGE_NON_FREE, 1, &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), VK_DESCRIPTOR_POOL_USAGE_NON_FREE, 1, &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1917,7 +1917,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -1931,7 +1931,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkPipelineShaderStageCreateInfo shaderStages[3];
@@ -1987,9 +1987,9 @@
VkPipeline pipeline;
VkPipelineCache pipelineCache;
- err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+ err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
ASSERT_VK_SUCCESS(err);
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Tess Gfx Pipeline w/ 0 patchControlPoints.";
@@ -1997,10 +1997,10 @@
FAIL() << "Error received was not 'Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH primitive...' but instead '" << msgString.c_str() << "'";
}
- vkDestroyPipelineCache(m_device->device(), pipelineCache);
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
*/
// Set scissor and viewport counts to different numbers
@@ -2026,7 +2026,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2040,7 +2040,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -2058,7 +2058,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkViewport vp = {}; // Just need dummy vp to point to
@@ -2096,9 +2096,9 @@
VkPipeline pipeline;
VkPipelineCache pipelineCache;
- err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+ err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
ASSERT_VK_SUCCESS(err);
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/ viewport and scissor count mismatch.";
@@ -2106,10 +2106,10 @@
FAIL() << "Error received was not 'Gfx Pipeline viewport count (1) must match scissor count (0).' but instead it was '" << msgString.c_str() << "'";
}
- vkDestroyPipelineCache(m_device->device(), pipelineCache);
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
// Don't set viewport state in PSO. This is an error b/c we always need this state
// for the counts even if the data is going to be set dynamically.
@@ -2135,7 +2135,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2149,7 +2149,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -2167,7 +2167,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkDynamicState sc_state = VK_DYNAMIC_STATE_SCISSOR;
@@ -2205,9 +2205,9 @@
VkPipeline pipeline;
VkPipelineCache pipelineCache;
- err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+ err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
ASSERT_VK_SUCCESS(err);
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o viewport state set.";
@@ -2215,10 +2215,10 @@
FAIL() << "Error received was not 'Gfx Pipeline pViewportState is null. Even if...' but instead it was '" << msgString.c_str() << "'";
}
- vkDestroyPipelineCache(m_device->device(), pipelineCache);
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
// Create PSO w/o non-zero viewportCount but no viewport data
// Then run second test where dynamic scissor count doesn't match PSO scissor count
@@ -2243,7 +2243,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2257,7 +2257,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -2275,7 +2275,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkPipelineViewportStateCreateInfo vp_state_ci = {};
@@ -2344,9 +2344,9 @@
VkPipeline pipeline;
VkPipelineCache pipelineCache;
- err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+ err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
ASSERT_VK_SUCCESS(err);
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o scissor set.";
@@ -2358,7 +2358,7 @@
// First need to successfully create the PSO from above by setting pViewports
VkViewport vp = {}; // Just need dummy vp to point to
vp_state_ci.pViewports = &vp;
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
ASSERT_VK_SUCCESS(err);
BeginCommandBuffer();
vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
@@ -2373,10 +2373,10 @@
FAIL() << "Error received was not 'Dynamic scissorCount from vkCmdSetScissor() is 2, but PSO scissorCount is 1...' but instead it was '" << msgString.c_str() << "'";
}
- vkDestroyPipelineCache(m_device->device(), pipelineCache);
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
// Create PSO w/o non-zero scissorCount but no scissor data
// Then run second test where dynamic viewportCount doesn't match PSO viewportCount
@@ -2401,7 +2401,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2415,7 +2415,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -2433,7 +2433,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkPipelineViewportStateCreateInfo vp_state_ci = {};
@@ -2502,9 +2502,9 @@
VkPipeline pipeline;
VkPipelineCache pipelineCache;
- err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+ err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
ASSERT_VK_SUCCESS(err);
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o scissor set.";
@@ -2516,7 +2516,7 @@
// First need to successfully create the PSO from above by setting pViewports
VkRect2D sc = {}; // Just need dummy vp to point to
vp_state_ci.pScissors = ≻
- err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+ err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
ASSERT_VK_SUCCESS(err);
BeginCommandBuffer();
vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
@@ -2531,10 +2531,10 @@
FAIL() << "Error received was not 'Dynamic viewportCount from vkCmdSetViewport() is 2, but PSO viewportCount is 1...' but instead it was '" << msgString.c_str() << "'";
}
- vkDestroyPipelineCache(m_device->device(), pipelineCache);
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, NullRenderPass)
@@ -2802,7 +2802,7 @@
buffCI.pQueueFamilyIndices = &qfi;
VkBuffer ib;
- err = vkCreateBuffer(m_device->device(), &buffCI, &ib);
+ err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &ib);
ASSERT_VK_SUCCESS(err);
BeginCommandBuffer();
@@ -2817,7 +2817,7 @@
FAIL() << "Error received was not 'vkCmdBindIndexBuffer() offset (0x7) does not fall on ...' but instead '" << msgString.c_str() << "'";
}
- vkDestroyBuffer(m_device->device(), ib);
+ vkDestroyBuffer(m_device->device(), ib, NULL);
}
TEST_F(VkLayerTest, ExecuteCommandsPrimaryCB)
@@ -2864,7 +2864,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
dsl_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
@@ -2879,7 +2879,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -2910,7 +2910,7 @@
sampler_ci.unnormalizedCoordinates = VK_FALSE;
VkSampler sampler;
- err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+ err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
ASSERT_VK_SUCCESS(err);
VkDescriptorImageInfo info = {};
@@ -2933,9 +2933,9 @@
FAIL() << "Error received was not 'Write descriptor update has descriptor type VK_DESCRIPTOR_TYPE_SAMPLER that does not match...' but instead '" << msgString.c_str() << "'";
}
- vkDestroySampler(m_device->device(), sampler);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroySampler(m_device->device(), sampler, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, DSUpdateOutOfBounds)
@@ -2960,7 +2960,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2976,7 +2976,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3007,7 +3007,7 @@
sampler_ci.unnormalizedCoordinates = VK_FALSE;
VkSampler sampler;
- err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+ err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
ASSERT_VK_SUCCESS(err);
VkDescriptorImageInfo info = {};
@@ -3031,9 +3031,9 @@
FAIL() << "Error received was not 'Descriptor update type of VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET is out of bounds for matching binding...'";
}
- vkDestroySampler(m_device->device(), sampler);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroySampler(m_device->device(), sampler, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, InvalidDSUpdateIndex)
@@ -3058,7 +3058,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3073,7 +3073,7 @@
ds_layout_ci.bindingCount = 1;
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3104,7 +3104,7 @@
sampler_ci.unnormalizedCoordinates = VK_FALSE;
VkSampler sampler;
- err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+ err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
ASSERT_VK_SUCCESS(err);
VkDescriptorImageInfo info = {};
@@ -3128,9 +3128,9 @@
FAIL() << "Error received was not 'Descriptor Set <blah> does not have binding to match update binding '";
}
- vkDestroySampler(m_device->device(), sampler);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroySampler(m_device->device(), sampler, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, InvalidDSUpdateStruct)
@@ -3155,7 +3155,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
dsl_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
@@ -3170,7 +3170,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3200,7 +3200,7 @@
sampler_ci.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
sampler_ci.unnormalizedCoordinates = VK_FALSE;
VkSampler sampler;
- err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+ err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
ASSERT_VK_SUCCESS(err);
@@ -3224,9 +3224,9 @@
FAIL() << "Error received was not 'Unexpected UPDATE struct of type '";
}
- vkDestroySampler(m_device->device(), sampler);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroySampler(m_device->device(), sampler, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, SampleDescriptorUpdateError)
@@ -3251,7 +3251,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3266,7 +3266,7 @@
ds_layout_ci.bindingCount = 1;
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3301,8 +3301,8 @@
FAIL() << "Error received was not 'Attempt to update descriptor with invalid sampler...' but instead '" << msgString.c_str() << "'";
}
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, ImageViewDescriptorUpdateError)
@@ -3326,7 +3326,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3341,7 +3341,7 @@
ds_layout_ci.bindingCount = 1;
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3372,7 +3372,7 @@
sampler_ci.unnormalizedCoordinates = VK_FALSE;
VkSampler sampler;
- err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+ err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
ASSERT_VK_SUCCESS(err);
VkImageView view = (VkImageView) 0xbaadbeef; // invalid imageView object
@@ -3399,9 +3399,9 @@
FAIL() << "Error received was not 'Attempt to update descriptor with invalid imageView...' but instead '" << msgString.c_str() << "'";
}
- vkDestroySampler(m_device->device(), sampler);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroySampler(m_device->device(), sampler, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, CopyDescriptorUpdateErrors)
@@ -3428,7 +3428,7 @@
ds_pool_ci.pTypeCounts = ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding[2] = {};
dsl_binding[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
@@ -3447,7 +3447,7 @@
ds_layout_ci.pBindings = dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3478,7 +3478,7 @@
sampler_ci.unnormalizedCoordinates = VK_FALSE;
VkSampler sampler;
- err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+ err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
ASSERT_VK_SUCCESS(err);
VkDescriptorImageInfo info = {};
@@ -3541,9 +3541,9 @@
FAIL() << "Error received was not 'Copy descriptor src update is out of bounds for matching binding 1...' but instead '" << msgString.c_str() << "'";
}
- vkDestroySampler(m_device->device(), sampler);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroySampler(m_device->device(), sampler, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, NumSamplesMismatch)
@@ -3568,7 +3568,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3584,7 +3584,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3611,7 +3611,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -3632,9 +3632,9 @@
FAIL() << "Error received was not 'Num samples mismatch!...'";
}
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, ClearCmdNoDraw)
@@ -3660,7 +3660,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3676,7 +3676,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3703,7 +3703,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -3736,9 +3736,9 @@
FAIL() << "Error received was not 'vkCmdClearAttachments() issued on CB object...'";
}
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
TEST_F(VkLayerTest, VtxBufferBadIndex)
@@ -3765,7 +3765,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3781,7 +3781,7 @@
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -3808,7 +3808,7 @@
pipeline_layout_ci.pSetLayouts = &ds_layout;
VkPipelineLayout pipeline_layout;
- err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+ err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
ASSERT_VK_SUCCESS(err);
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -3836,9 +3836,9 @@
FAIL() << "Error received was not 'Vtx Buffer Index 0 was bound, but no vtx buffers are attached to PSO.' but instead was '" << msgString.c_str() << "'";
}
- vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
#endif // DRAW_STATE_TESTS
@@ -3889,7 +3889,7 @@
memset(&event_info, 0, sizeof(event_info));
event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
- err = vkCreateEvent(device(), &event_info, &event);
+ err = vkCreateEvent(device(), &event_info, NULL, &event);
ASSERT_VK_SUCCESS(err);
err = vkResetEvent(device(), event);
@@ -3914,7 +3914,7 @@
FAIL() << "Error received was not 'THREADING ERROR'";
}
- vkDestroyEvent(device(), event);
+ vkDestroyEvent(device(), event, NULL);
}
#endif // GTEST_IS_THREADSAFE
#endif // THREADING_TESTS
@@ -3942,7 +3942,7 @@
moduleCreateInfo.pCode = (const uint32_t *) &spv;
moduleCreateInfo.codeSize = 4;
moduleCreateInfo.flags = 0;
- vkCreateShaderModule(m_device->device(), &moduleCreateInfo, &module);
+ vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
msgFlags = m_errorMonitor->GetState(&msgString);
@@ -3974,7 +3974,7 @@
moduleCreateInfo.pCode = (const uint32_t *) &spv;
moduleCreateInfo.codeSize = sizeof(spv) + 10;
moduleCreateInfo.flags = 0;
- vkCreateShaderModule(m_device->device(), &moduleCreateInfo, &module);
+ vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
msgFlags = m_errorMonitor->GetState(&msgString);
@@ -4007,7 +4007,7 @@
moduleCreateInfo.pCode = (const uint32_t *) &spv;
moduleCreateInfo.codeSize = sizeof(spv) + 10;
moduleCreateInfo.flags = 0;
- vkCreateShaderModule(m_device->device(), &moduleCreateInfo, &module);
+ vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
msgFlags = m_errorMonitor->GetState(&msgString);
@@ -4636,7 +4636,7 @@
// Introduce error by sending down a bogus width extent
image_create_info.extent.width = 65536;
- vkCreateImage(m_device->device(), &image_create_info, &image);
+ vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error while creating an image" <<
@@ -4684,7 +4684,7 @@
image_create_info.arrayLayers = 4;
image_create_info.samples = 2;
image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
- vkCreateImage(m_device->device(), &image_create_info, &image);
+ vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error while creating an image" <<
@@ -4787,7 +4787,7 @@
image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &image);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
ASSERT_VK_SUCCESS(err);
VkImageViewCreateInfo image_view_create_info = {};
@@ -4801,7 +4801,7 @@
image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
VkImageView view;
- err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
+ err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error while creating an invalid ImageView";
@@ -4840,7 +4840,7 @@
image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &image);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
ASSERT_VK_SUCCESS(err);
VkImageViewCreateInfo image_view_create_info = {};
@@ -4854,7 +4854,7 @@
image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
VkImageView view;
- err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
+ err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error when specifying an invalid ImageView aspect";
@@ -4895,13 +4895,13 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
ASSERT_VK_SUCCESS(err);
image_create_info.imageType = VK_IMAGE_TYPE_1D;
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
- err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
ASSERT_VK_SUCCESS(err);
// Allocate memory
@@ -4915,14 +4915,14 @@
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_VK_SUCCESS(err);
- err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
ASSERT_VK_SUCCESS(err);
err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -4958,10 +4958,10 @@
FAIL() << "Error received was not 'vkCmdCopyImage called with unmatched source and dest image types' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), srcImage);
- vkDestroyImage(m_device->device(), destImage);
- vkFreeMemory(m_device->device(), srcMem);
- vkFreeMemory(m_device->device(), destMem);
+ vkDestroyImage(m_device->device(), srcImage, NULL);
+ vkDestroyImage(m_device->device(), destImage, NULL);
+ vkFreeMemory(m_device->device(), srcMem, NULL);
+ vkFreeMemory(m_device->device(), destMem, NULL);
}
TEST_F(VkLayerTest, CopyImageFormatSizeMismatch)
@@ -5001,13 +5001,13 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
ASSERT_VK_SUCCESS(err);
image_create_info.imageType = VK_IMAGE_TYPE_1D;
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
- err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
ASSERT_VK_SUCCESS(err);
// Allocate memory
@@ -5021,14 +5021,14 @@
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
ASSERT_VK_SUCCESS(err);
err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5064,10 +5064,10 @@
FAIL() << "Error received was not 'vkCmdCopyImage called with unmatched source and dest image types' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), srcImage);
- vkDestroyImage(m_device->device(), destImage);
- vkFreeMemory(m_device->device(), srcMem);
- vkFreeMemory(m_device->device(), destMem);
+ vkDestroyImage(m_device->device(), srcImage, NULL);
+ vkDestroyImage(m_device->device(), destImage, NULL);
+ vkFreeMemory(m_device->device(), srcMem, NULL);
+ vkFreeMemory(m_device->device(), destMem, NULL);
}
TEST_F(VkLayerTest, ResolveImageLowSampleCount)
@@ -5102,13 +5102,13 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
ASSERT_VK_SUCCESS(err);
image_create_info.imageType = VK_IMAGE_TYPE_1D;
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
- err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
ASSERT_VK_SUCCESS(err);
// Allocate memory
@@ -5122,14 +5122,14 @@
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
ASSERT_VK_SUCCESS(err);
err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5168,10 +5168,10 @@
FAIL() << "Error received was not 'vkCmdResolveImage called with source sample count less than 2.' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), srcImage);
- vkDestroyImage(m_device->device(), destImage);
- vkFreeMemory(m_device->device(), srcMem);
- vkFreeMemory(m_device->device(), destMem);
+ vkDestroyImage(m_device->device(), srcImage, NULL);
+ vkDestroyImage(m_device->device(), destImage, NULL);
+ vkFreeMemory(m_device->device(), srcMem, NULL);
+ vkFreeMemory(m_device->device(), destMem, NULL);
}
TEST_F(VkLayerTest, ResolveImageHighSampleCount)
@@ -5207,14 +5207,14 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
ASSERT_VK_SUCCESS(err);
image_create_info.imageType = VK_IMAGE_TYPE_1D;
// Note: Some implementations expect color attachment usage for any multisample surface
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
- err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
ASSERT_VK_SUCCESS(err);
// Allocate memory
@@ -5228,14 +5228,14 @@
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
ASSERT_VK_SUCCESS(err);
err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5274,10 +5274,10 @@
FAIL() << "Error received was not 'vkCmdResolveImage called with dest sample count greater than 1.' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), srcImage);
- vkDestroyImage(m_device->device(), destImage);
- vkFreeMemory(m_device->device(), srcMem);
- vkFreeMemory(m_device->device(), destMem);
+ vkDestroyImage(m_device->device(), srcImage, NULL);
+ vkDestroyImage(m_device->device(), destImage, NULL);
+ vkFreeMemory(m_device->device(), srcMem, NULL);
+ vkFreeMemory(m_device->device(), destMem, NULL);
}
TEST_F(VkLayerTest, ResolveImageFormatMismatch)
@@ -5313,7 +5313,7 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
ASSERT_VK_SUCCESS(err);
// Set format to something other than source image
@@ -5322,7 +5322,7 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
image_create_info.samples = 1;
- err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
ASSERT_VK_SUCCESS(err);
// Allocate memory
@@ -5336,14 +5336,14 @@
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
ASSERT_VK_SUCCESS(err);
err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5382,10 +5382,10 @@
FAIL() << "Error received was not 'vkCmdResolveImage called with unmatched source and dest formats.' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), srcImage);
- vkDestroyImage(m_device->device(), destImage);
- vkFreeMemory(m_device->device(), srcMem);
- vkFreeMemory(m_device->device(), destMem);
+ vkDestroyImage(m_device->device(), srcImage, NULL);
+ vkDestroyImage(m_device->device(), destImage, NULL);
+ vkFreeMemory(m_device->device(), srcMem, NULL);
+ vkFreeMemory(m_device->device(), destMem, NULL);
}
TEST_F(VkLayerTest, ResolveImageTypeMismatch)
@@ -5421,7 +5421,7 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
ASSERT_VK_SUCCESS(err);
image_create_info.imageType = VK_IMAGE_TYPE_1D;
@@ -5429,7 +5429,7 @@
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
image_create_info.samples = 1;
- err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
ASSERT_VK_SUCCESS(err);
// Allocate memory
@@ -5443,14 +5443,14 @@
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
ASSERT_VK_SUCCESS(err);
vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
memAlloc.allocationSize = memReqs.size;
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
ASSERT_TRUE(pass);
- err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+ err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
ASSERT_VK_SUCCESS(err);
err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5489,10 +5489,10 @@
FAIL() << "Error received was not 'vkCmdResolveImage called with unmatched source and dest image types.' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), srcImage);
- vkDestroyImage(m_device->device(), destImage);
- vkFreeMemory(m_device->device(), srcMem);
- vkFreeMemory(m_device->device(), destMem);
+ vkDestroyImage(m_device->device(), srcImage, NULL);
+ vkDestroyImage(m_device->device(), destImage, NULL);
+ vkFreeMemory(m_device->device(), srcMem, NULL);
+ vkFreeMemory(m_device->device(), destMem, NULL);
}
TEST_F(VkLayerTest, DepthStencilImageViewWithColorAspectBitError)
@@ -5519,7 +5519,7 @@
ds_pool_ci.pTypeCounts = &ds_type_count;
VkDescriptorPool ds_pool;
- err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+ err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
ASSERT_VK_SUCCESS(err);
VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -5534,7 +5534,7 @@
ds_layout_ci.bindingCount = 1;
ds_layout_ci.pBindings = &dsl_binding;
VkDescriptorSetLayout ds_layout;
- err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+ err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
ASSERT_VK_SUCCESS(err);
VkDescriptorSet descriptorSet;
@@ -5569,11 +5569,11 @@
image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
image_create_info.flags = 0;
- err = vkCreateImage(m_device->device(), &image_create_info, &image_bad);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image_bad);
ASSERT_VK_SUCCESS(err);
image_create_info.format = tex_format_good;
image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
- err = vkCreateImage(m_device->device(), &image_create_info, &image_good);
+ err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image_good);
ASSERT_VK_SUCCESS(err);
VkImageViewCreateInfo image_view_create_info = {};
@@ -5588,18 +5588,18 @@
image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
VkImageView view;
- err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
+ err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
msgFlags = m_errorMonitor->GetState(&msgString);
ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating ImageView for DS image w/ COLOR aspect bit set.";
if (!strstr(msgString.c_str(),"Combination depth/stencil image formats can have only the ")) {
FAIL() << "Error received was not 'Combination depth/stencil image formats can have only the....' but instead '" << msgString.c_str() << "'";
}
- vkDestroyImage(m_device->device(), image_bad);
- vkDestroyImage(m_device->device(), image_good);
- vkDestroyImageView(m_device->device(), view);
- vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
- vkDestroyDescriptorPool(m_device->device(), ds_pool);
+ vkDestroyImage(m_device->device(), image_bad, NULL);
+ vkDestroyImage(m_device->device(), image_good, NULL);
+ vkDestroyImageView(m_device->device(), view, NULL);
+ vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+ vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
}
#endif // IMAGE_TESTS
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 0709744..bdd0808 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -87,12 +87,11 @@
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_;
- inst_info.pAllocCb = NULL;
inst_info.enabledExtensionNameCount = instance_extension_names.size();
inst_info.ppEnabledExtensionNames = (instance_extension_names.size()) ? &instance_extension_names[0] : NULL;
inst_info.enabledLayerNameCount = 0;
inst_info.ppEnabledLayerNames = NULL;
- err = vkCreateInstance(&inst_info, &inst);
+ err = vkCreateInstance(&inst_info, NULL, &inst);
ASSERT_EQ(VK_SUCCESS, err);
err = vkEnumeratePhysicalDevices(inst, &count, NULL);
ASSERT_EQ(VK_SUCCESS, err);
@@ -132,6 +131,6 @@
devs_.clear();
if (inst)
- vkDestroyInstance(inst);
+ vkDestroyInstance(inst, NULL);
}
} // vk_testing namespace
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 1d868d5..2963b86 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -98,12 +98,11 @@
instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instInfo.pNext = NULL;
instInfo.pAppInfo = &app_info;
- instInfo.pAllocCb = NULL;
instInfo.enabledLayerNameCount = instance_layer_names.size();
instInfo.ppEnabledLayerNames = instance_layer_names.data();
instInfo.enabledExtensionNameCount = instance_extension_names.size();
instInfo.ppEnabledExtensionNames = instance_extension_names.data();
- err = vkCreateInstance(&instInfo, &this->inst);
+ err = vkCreateInstance(&instInfo, NULL, &this->inst);
ASSERT_VK_SUCCESS(err);
err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
@@ -151,17 +150,17 @@
{
if (m_cmdBuffer)
delete m_cmdBuffer;
- if (m_cmdPool) vkDestroyCommandPool(device(), m_cmdPool);
- if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer);
- if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass);
+ if (m_cmdPool) vkDestroyCommandPool(device(), m_cmdPool, NULL);
+ if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer, NULL);
+ if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass, NULL);
if (m_globalMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_globalMsgCallback);
if (m_devMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_devMsgCallback);
while (!m_renderTargets.empty()) {
- vkDestroyImageView(device(), m_renderTargets.back()->targetView(m_render_target_fmt));
- vkDestroyImage(device(), m_renderTargets.back()->image());
- vkFreeMemory(device(), m_renderTargets.back()->memory());
+ vkDestroyImageView(device(), m_renderTargets.back()->targetView(m_render_target_fmt), NULL);
+ vkDestroyImage(device(), m_renderTargets.back()->image(), NULL);
+ vkFreeMemory(device(), m_renderTargets.back()->memory(), NULL);
m_renderTargets.pop_back();
}
@@ -174,7 +173,7 @@
// reset the driver
delete m_device;
- if (this->inst) vkDestroyInstance(this->inst);
+ if (this->inst) vkDestroyInstance(this->inst, NULL);
}
void VkRenderFramework::InitState()
@@ -224,7 +223,7 @@
cmd_pool_info.pNext = NULL,
cmd_pool_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
cmd_pool_info.flags = 0,
- err = vkCreateCommandPool(device(), &cmd_pool_info, &m_cmdPool);
+ err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &m_cmdPool);
assert(!err);
m_cmdBuffer = new VkCommandBufferObj(m_device, m_cmdPool);
@@ -377,7 +376,7 @@
rp_info.subpassCount = 1;
rp_info.pSubpasses = &subpass;
- vkCreateRenderPass(device(), &rp_info, &m_renderPass);
+ vkCreateRenderPass(device(), &rp_info, NULL, &m_renderPass);
// Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
VkFramebufferCreateInfo fb_info = {};
@@ -390,7 +389,7 @@
fb_info.height = (uint32_t)m_height;
fb_info.layers = 1;
- vkCreateFramebuffer(device(), &fb_info, &m_framebuffer);
+ vkCreateFramebuffer(device(), &fb_info, NULL, &m_framebuffer);
m_renderPassBeginInfo.renderPass = m_renderPass;
m_renderPassBeginInfo.framebuffer = m_framebuffer;
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 3f8cf56..90944de 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -31,7 +31,7 @@
#define NON_DISPATCHABLE_HANDLE_INIT(create_func, dev, ...) \
do { \
handle_type handle; \
- if (EXPECT(create_func(dev.handle(), __VA_ARGS__, &handle) == VK_SUCCESS)) \
+ if (EXPECT(create_func(dev.handle(), __VA_ARGS__, NULL, &handle) == VK_SUCCESS)) \
NonDispHandle::init(dev.handle(), handle); \
} while (0)
@@ -39,7 +39,7 @@
cls::~cls() \
{ \
if (initialized()) \
- destroy_func(device(), handle()); \
+ destroy_func(device(), handle(), NULL); \
}
#define STRINGIFY(x) #x
@@ -260,7 +260,7 @@
queues_[i].clear();
}
- vkDestroyDevice(handle());
+ vkDestroyDevice(handle(), NULL);
}
void Device::init(std::vector<const char *> &layers, std::vector<const char *> &extensions)
@@ -300,7 +300,7 @@
{
VkDevice dev;
- if (EXPECT(vkCreateDevice(phy_.handle(), &info, &dev) == VK_SUCCESS))
+ if (EXPECT(vkCreateDevice(phy_.handle(), &info, NULL, &dev) == VK_SUCCESS))
Handle::init(dev);
init_queues();
@@ -427,7 +427,7 @@
DeviceMemory::~DeviceMemory()
{
if (initialized())
- vkFreeMemory(device(), handle());
+ vkFreeMemory(device(), handle(), NULL);
}
void DeviceMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
@@ -632,7 +632,7 @@
{
VkShaderModule mod;
- VkResult err = vkCreateShaderModule(dev.handle(), &info, &mod);
+ VkResult err = vkCreateShaderModule(dev.handle(), &info, NULL, &mod);
if (err == VK_SUCCESS)
NonDispHandle::init(dev.handle(), mod);
@@ -650,7 +650,7 @@
{
VkShader sh;
- VkResult err = vkCreateShader(dev.handle(), &info, &sh);
+ VkResult err = vkCreateShader(dev.handle(), &info, NULL, &sh);
if (err == VK_SUCCESS)
NonDispHandle::init(dev.handle(), sh);
@@ -665,10 +665,10 @@
VkPipelineCacheCreateInfo ci;
memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
- VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
+ VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
if (err == VK_SUCCESS) {
NON_DISPATCHABLE_HANDLE_INIT(vkCreateGraphicsPipelines, dev, cache, 1, &info);
- vkDestroyPipelineCache(dev.handle(), cache);
+ vkDestroyPipelineCache(dev.handle(), cache, NULL);
}
}
@@ -679,14 +679,14 @@
VkPipelineCacheCreateInfo ci;
memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
- VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
+ VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
EXPECT(err == VK_SUCCESS);
if (err == VK_SUCCESS) {
- err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, &pipe);
+ err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, NULL, &pipe);
if (err == VK_SUCCESS) {
NonDispHandle::init(dev.handle(), pipe);
}
- vkDestroyPipelineCache(dev.handle(), cache);
+ vkDestroyPipelineCache(dev.handle(), cache, NULL);
}
return err;
@@ -698,10 +698,10 @@
VkPipelineCacheCreateInfo ci;
memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
- VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
+ VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
if (err == VK_SUCCESS) {
NON_DISPATCHABLE_HANDLE_INIT(vkCreateComputePipelines, dev, cache, 1, &info);
- vkDestroyPipelineCache(dev.handle(), cache);
+ vkDestroyPipelineCache(dev.handle(), cache, NULL);
}
}
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index 1cab1c0..33a090d 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -522,7 +522,7 @@
err = vkCreateSemaphore(m_device.handle(),
&presentCompleteSemaphoreCreateInfo,
- &presentCompleteSemaphore);
+ NULL, &presentCompleteSemaphore);
assert(!err);
// Get the index of the next available swapchain image:
@@ -597,7 +597,7 @@
vkQueueSubmit(m_queue.handle(), 1, &submit_info, nullFence);
m_queue.wait();
- vkDestroySemaphore(m_device.handle(), presentCompleteSemaphore);
+ vkDestroySemaphore(m_device.handle(), presentCompleteSemaphore, NULL);
VkPresentInfoKHR present = {};
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
@@ -966,7 +966,7 @@
color_image_view.image = m_buffers[i].image;
err = vkCreateImageView(m_device.handle(),
- &color_image_view, &m_buffers[i].view);
+ &color_image_view, NULL, &m_buffers[i].view);
assert(!err);
/* Set image layout to PRESENT_SOURCE_KHR so that before the copy, it can be set to */
@@ -1188,7 +1188,7 @@
m_fpDestroySwapchainKHR(m_device.handle(), m_swap_chain);
for (uint32_t i = 0; i < m_swapchainImageCount; i++) {
- vkDestroyImageView(m_device.handle(), m_buffers[i].view);
+ vkDestroyImageView(m_device.handle(), m_buffers[i].view, NULL);
}
#ifndef _WIN32
xcb_destroy_window(m_connection, m_window);
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 4cef744..65b737a 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -687,7 +687,7 @@
'{\n'
' dispatch_key key = get_dispatch_key(device);\n'
' VkLayerDispatchTable *pDisp = device_dispatch_table(device);\n'
- ' pDisp->DestroyDevice(device);\n'
+ ' pDisp->DestroyDevice(device, pAllocator);\n'
' deviceExtMap.erase(pDisp);\n'
' destroy_device_dispatch_table(key);\n'
'}\n' % (qual, decl))
@@ -697,7 +697,7 @@
'{\n'
' dispatch_key key = get_dispatch_key(instance);\n'
' VkLayerInstanceDispatchTable *pDisp = instance_dispatch_table(instance);\n'
- ' pDisp->DestroyInstance(instance);\n'
+ ' pDisp->DestroyInstance(instance, pAllocator);\n'
' // Clean up logging callback, if any\n'
' layer_data *my_data = get_my_data_ptr(key, layer_data_map);\n'
' if (my_data->logging_callback) {\n'
@@ -1367,7 +1367,8 @@
gedi_txt = []
gedi_txt.append('%s' % self.lineinfo.get())
gedi_txt.append('void vkDestroyInstance(')
- gedi_txt.append('VkInstance instance)')
+ gedi_txt.append('VkInstance instance,')
+ gedi_txt.append('const VkAllocCallbacks* pAllocator)')
gedi_txt.append('{')
gedi_txt.append(' loader_platform_thread_lock_mutex(&objLock);')
gedi_txt.append(' validate_object(instance, instance);')
@@ -1387,7 +1388,7 @@
gedi_txt.append('')
gedi_txt.append(' dispatch_key key = get_dispatch_key(instance);')
gedi_txt.append(' VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, instance);')
- gedi_txt.append(' pInstanceTable->DestroyInstance(instance);')
+ gedi_txt.append(' pInstanceTable->DestroyInstance(instance, pAllocator);')
gedi_txt.append('')
gedi_txt.append(' // Clean up logging callback, if any')
gedi_txt.append(' layer_data *my_data = get_my_data_ptr(key, layer_data_map);')
@@ -1415,7 +1416,8 @@
gedd_txt = []
gedd_txt.append('%s' % self.lineinfo.get())
gedd_txt.append('void vkDestroyDevice(')
- gedd_txt.append('VkDevice device)')
+ gedd_txt.append('VkDevice device,')
+ gedd_txt.append('const VkAllocCallbacks* pAllocator)')
gedd_txt.append('{')
gedd_txt.append(' loader_platform_thread_lock_mutex(&objLock);')
gedd_txt.append(' validate_object(device, device);')
@@ -1443,7 +1445,7 @@
gedd_txt.append('')
gedd_txt.append(' dispatch_key key = get_dispatch_key(device);')
gedd_txt.append(' VkLayerDispatchTable *pDisp = get_dispatch_table(ObjectTracker_device_table_map, device);')
- gedd_txt.append(' pDisp->DestroyDevice(device);')
+ gedd_txt.append(' pDisp->DestroyDevice(device, pAllocator);')
gedd_txt.append(' ObjectTracker_device_table_map.erase(key);')
gedd_txt.append(' assert(ObjectTracker_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");')
gedd_txt.append('')
@@ -1585,7 +1587,7 @@
funcs.append('%s\n' % self.lineinfo.get())
destroy_line = ' loader_platform_thread_lock_mutex(&objLock);\n'
# destroy_line += ' if (result == VK_SUCCESS) {\n'
- destroy_line += ' destroy_obj(%s, %s);\n' % (param0_name, proto.params[-1].name)
+ destroy_line += ' destroy_obj(%s, %s);\n' % (param0_name, proto.params[-2].name)
# destroy_line += ' }\n'
destroy_line += ' loader_platform_thread_unlock_mutex(&objLock);\n'
if len(loop_params) > 0:
@@ -1904,7 +1906,7 @@
funcs.append('%s%s\n'
'{\n'
' VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(Threading_instance_table_map, *pInstance);\n'
- ' VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pInstance);\n'
+ ' VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pAllocator, pInstance);\n'
'\n'
' if (result == VK_SUCCESS) {\n'
' layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);\n'
diff --git a/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp b/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp
index 860565a..57743e3 100644
--- a/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp
+++ b/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp
@@ -243,21 +243,18 @@
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pNext = NULL;
createInfo.pAppInfo = pPacket->pCreateInfo->pAppInfo;
- createInfo.pAllocCb = NULL;
createInfo.enabledLayerNameCount = 0;
createInfo.ppEnabledLayerNames = NULL;
createInfo.enabledExtensionNameCount = instance_extension_count;
// createInfo.ppEnabledExtensionNames = requiredLayerNames;
// make the call
- replayResult = m_vkFuncs.real_vkCreateInstance(&createInfo, &inst);
+ replayResult = m_vkFuncs.real_vkCreateInstance(&createInfo, NULL, &inst);
// clean up
free(instance_extensions);
} else {
- VkAllocCallbacks **pACB = (VkAllocCallbacks**) & pPacket->pCreateInfo->pAllocCb;
const char strScreenShot[] = "ScreenShot";
- *pACB = NULL;
pCreateInfo = (VkInstanceCreateInfo *) pPacket->pCreateInfo;
if (g_pReplaySettings->screenshotList != NULL) {
// enable screenshot layer if it is available and not already in list
@@ -296,7 +293,7 @@
vktrace_free(props);
}
}
- replayResult = m_vkFuncs.real_vkCreateInstance(pPacket->pCreateInfo, &inst);
+ replayResult = m_vkFuncs.real_vkCreateInstance(pPacket->pCreateInfo, NULL, &inst);
if (ppEnabledLayerNames) {
// restore the packets CreateInfo struct
vktrace_free(ppEnabledLayerNames[pCreateInfo->enabledLayerNameCount - 1]);
@@ -370,7 +367,7 @@
vktrace_free(props);
}
}
- replayResult = m_vkFuncs.real_vkCreateDevice(remappedPhysicalDevice, pPacket->pCreateInfo, &device);
+ replayResult = m_vkFuncs.real_vkCreateDevice(remappedPhysicalDevice, pPacket->pCreateInfo, NULL, &device);
if (ppEnabledLayerNames)
{
// restore the packets CreateInfo struct
@@ -838,7 +835,7 @@
// End manual code
// No need to remap pCreateInfo
- replayResult = m_vkFuncs.real_vkCreateShader(remappeddevice, pPacket->pCreateInfo, &local_pShader);
+ replayResult = m_vkFuncs.real_vkCreateShader(remappeddevice, pPacket->pCreateInfo, NULL, &local_pShader);
if (replayResult == VK_SUCCESS)
{
m_objMapper.add_to_shaders_map(*(pPacket->pShader), local_pShader);
@@ -1046,7 +1043,7 @@
pInfo = (VkDescriptorSetLayoutCreateInfo*)pPacket->pCreateInfo->pNext;
}
VkDescriptorSetLayout setLayout;
- replayResult = m_vkFuncs.real_vkCreateDescriptorSetLayout(remappedDevice, pPacket->pCreateInfo, &setLayout);
+ replayResult = m_vkFuncs.real_vkCreateDescriptorSetLayout(remappedDevice, pPacket->pCreateInfo, NULL, &setLayout);
if (replayResult == VK_SUCCESS)
{
m_objMapper.add_to_descriptorsetlayouts_map(*(pPacket->pSetLayout), setLayout);
@@ -1062,7 +1059,7 @@
return;
}
- m_vkFuncs.real_vkDestroyDescriptorSetLayout(remappedDevice, pPacket->descriptorSetLayout);
+ m_vkFuncs.real_vkDestroyDescriptorSetLayout(remappedDevice, pPacket->descriptorSetLayout, NULL);
m_objMapper.rm_from_descriptorsetlayouts_map(pPacket->descriptorSetLayout);
}
@@ -1274,7 +1271,7 @@
VkPipeline *local_pPipelines = VKTRACE_NEW_ARRAY(VkPipeline, pPacket->createInfoCount);
- replayResult = m_vkFuncs.real_vkCreateGraphicsPipelines(remappedDevice, pipelineCache, createInfoCount, pLocalCIs, local_pPipelines);
+ replayResult = m_vkFuncs.real_vkCreateGraphicsPipelines(remappedDevice, pipelineCache, createInfoCount, pLocalCIs, NULL, local_pPipelines);
if (replayResult == VK_SUCCESS)
{
@@ -1311,7 +1308,7 @@
*pSL = m_objMapper.remap_descriptorsetlayouts(pPacket->pCreateInfo->pSetLayouts[i]);
}
VkPipelineLayout localPipelineLayout;
- replayResult = m_vkFuncs.real_vkCreatePipelineLayout(remappedDevice, pPacket->pCreateInfo, &localPipelineLayout);
+ replayResult = m_vkFuncs.real_vkCreatePipelineLayout(remappedDevice, pPacket->pCreateInfo, NULL, &localPipelineLayout);
if (replayResult == VK_SUCCESS)
{
m_objMapper.add_to_pipelinelayouts_map(*(pPacket->pPipelineLayout), localPipelineLayout);
@@ -1452,7 +1449,7 @@
pInfo->renderPass = m_objMapper.remap_renderpasss(pPacket->pCreateInfo->renderPass);
VkFramebuffer local_framebuffer;
- replayResult = m_vkFuncs.real_vkCreateFramebuffer(remappedDevice, pPacket->pCreateInfo, &local_framebuffer);
+ replayResult = m_vkFuncs.real_vkCreateFramebuffer(remappedDevice, pPacket->pCreateInfo, NULL, &local_framebuffer);
pInfo->pAttachments = pSavedAttachments;
pInfo->renderPass = savedRP;
if (replayResult == VK_SUCCESS)
@@ -1475,7 +1472,7 @@
return VK_ERROR_VALIDATION_FAILED;
VkRenderPass local_renderpass;
- replayResult = m_vkFuncs.real_vkCreateRenderPass(remappedDevice, pPacket->pCreateInfo, &local_renderpass);
+ replayResult = m_vkFuncs.real_vkCreateRenderPass(remappedDevice, pPacket->pCreateInfo, NULL, &local_renderpass);
if (replayResult == VK_SUCCESS)
{
m_objMapper.add_to_renderpasss_map(*(pPacket->pRenderPass), local_renderpass);
@@ -1614,7 +1611,7 @@
gpuMemObj local_mem;
if (!m_objMapper.m_adjustForGPU)
- replayResult = m_vkFuncs.real_vkAllocMemory(remappedDevice, pPacket->pAllocInfo, &local_mem.replayGpuMem);
+ replayResult = m_vkFuncs.real_vkAllocMemory(remappedDevice, pPacket->pAllocInfo, NULL, &local_mem.replayGpuMem);
if (replayResult == VK_SUCCESS || m_objMapper.m_adjustForGPU)
{
local_mem.pGpuMem = new (gpuMemory);
@@ -1636,7 +1633,7 @@
gpuMemObj local_mem;
local_mem = m_objMapper.m_devicememorys.find(pPacket->mem)->second;
// TODO how/when to free pendingAlloc that did not use and existing gpuMemObj
- m_vkFuncs.real_vkFreeMemory(remappedDevice, local_mem.replayGpuMem);
+ m_vkFuncs.real_vkFreeMemory(remappedDevice, local_mem.replayGpuMem, NULL);
delete local_mem.pGpuMem;
m_objMapper.rm_from_devicememorys_map(pPacket->mem);
}
diff --git a/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp b/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp
index 4ebcf69..cb29767 100644
--- a/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp
+++ b/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp
@@ -113,21 +113,24 @@
VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo* pAllocInfo,
+ const VkAllocCallbacks* pAllocator,
VkDeviceMemory* pMem)
{
vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkAllocMemory* pPacket = NULL;
CREATE_TRACE_PACKET(vkAllocMemory, get_struct_chain_size((void*)pAllocInfo) + sizeof(VkDeviceMemory));
- result = mdd(device)->devTable.AllocMemory(device, pAllocInfo, pMem);
+ result = mdd(device)->devTable.AllocMemory(device, pAllocInfo, pAllocator, pMem);
vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkAllocMemory(pHeader);
pPacket->device = device;
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(VkMemoryAllocInfo), pAllocInfo);
add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(VkDeviceMemory), pMem);
pPacket->result = result;
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
FINISH_TRACE_PACKET();
// begin custom code
@@ -207,16 +210,19 @@
VKTRACER_EXPORT void VKAPI __HOOKED_vkFreeMemory(
VkDevice device,
- VkDeviceMemory mem)
+ VkDeviceMemory mem,
+ const VkAllocCallbacks* pAllocator)
{
vktrace_trace_packet_header* pHeader;
packet_vkFreeMemory* pPacket = NULL;
CREATE_TRACE_PACKET(vkFreeMemory, 0);
- mdd(device)->devTable.FreeMemory(device, mem);
+ mdd(device)->devTable.FreeMemory(device, mem, pAllocator);
vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkFreeMemory(pHeader);
pPacket->device = device;
pPacket->mem = mem;
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
FINISH_TRACE_PACKET();
// begin custom code
rm_handle_from_mem_info(mem);
@@ -294,6 +300,7 @@
VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
vktrace_trace_packet_header* pHeader;
@@ -302,16 +309,18 @@
// begin custom code (needs to use get_struct_chain_size)
CREATE_TRACE_PACKET(vkCreateDescriptorPool, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDescriptorPool));
// end custom code
- result = mdd(device)->devTable.CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+ result = mdd(device)->devTable.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateDescriptorPool(pHeader);
pPacket->device = device;
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCounts), pCreateInfo->typeCount * sizeof(VkDescriptorTypeCount), pCreateInfo->pTypeCounts);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorPool), sizeof(VkDescriptorPool), pDescriptorPool);
pPacket->result = result;
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCounts));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorPool));
FINISH_TRACE_PACKET();
return result;
@@ -320,6 +329,7 @@
VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkDevice* pDevice)
{
vktrace_trace_packet_header* pHeader;
@@ -327,7 +337,7 @@
packet_vkCreateDevice* pPacket = NULL;
CREATE_TRACE_PACKET(vkCreateDevice, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDevice));
- result = mdd(*pDevice)->devTable.CreateDevice(physicalDevice, pCreateInfo, pDevice);
+ result = mdd(*pDevice)->devTable.CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
if (result == VK_SUCCESS)
ext_init_create_device(mdd(*pDevice), *pDevice, pCreateInfo->enabledExtensionNameCount, pCreateInfo->ppEnabledExtensionNames);
@@ -335,8 +345,10 @@
pPacket = interpret_body_as_vkCreateDevice(pHeader);
pPacket->physicalDevice = physicalDevice;
add_VkDeviceCreateInfo_to_packet(pHeader, (VkDeviceCreateInfo**) &(pPacket->pCreateInfo), pCreateInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDevice), sizeof(VkDevice), pDevice);
pPacket->result = result;
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDevice));
FINISH_TRACE_PACKET();
return result;
@@ -345,6 +357,7 @@
VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkFramebuffer* pFramebuffer)
{
vktrace_trace_packet_header* pHeader;
@@ -354,16 +367,18 @@
uint32_t attachmentCount = (pCreateInfo != NULL && pCreateInfo->pAttachments != NULL) ? pCreateInfo->attachmentCount : 0;
CREATE_TRACE_PACKET(vkCreateFramebuffer, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkFramebuffer));
// end custom code
- result = mdd(device)->devTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ result = mdd(device)->devTable.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateFramebuffer(pHeader);
pPacket->device = device;
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments), attachmentCount * sizeof(VkImageView), pCreateInfo->pAttachments);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pFramebuffer), sizeof(VkFramebuffer), pFramebuffer);
pPacket->result = result;
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pFramebuffer));
FINISH_TRACE_PACKET();
return result;
@@ -371,6 +386,7 @@
VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkInstance* pInstance)
{
vktrace_trace_packet_header* pHeader;
@@ -381,7 +397,7 @@
uint64_t vktraceStartTime = vktrace_get_time();
SEND_ENTRYPOINT_ID(vkCreateInstance);
startTime = vktrace_get_time();
- result = mid(*pInstance)->instTable.CreateInstance(pCreateInfo, pInstance);
+ result = mid(*pInstance)->instTable.CreateInstance(pCreateInfo, pAllocator, pInstance);
endTime = vktrace_get_time();
if (result == VK_SUCCESS)
ext_init_create_instance(mid(*pInstance), *pInstance, pCreateInfo->enabledExtensionNameCount, pCreateInfo->ppEnabledExtensionNames);
@@ -393,8 +409,10 @@
pPacket = interpret_body_as_vkCreateInstance(pHeader);
add_VkInstanceCreateInfo_to_packet(pHeader, (VkInstanceCreateInfo**)&(pPacket->pCreateInfo), (VkInstanceCreateInfo*) pCreateInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInstance), sizeof(VkInstance), pInstance);
pPacket->result = result;
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pInstance));
FINISH_TRACE_PACKET();
return result;
@@ -403,6 +421,7 @@
VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
vktrace_trace_packet_header* pHeader;
@@ -414,7 +433,7 @@
uint32_t subpassCount = (pCreateInfo != NULL && (pCreateInfo->pSubpasses != NULL)) ? pCreateInfo->subpassCount : 0;
CREATE_TRACE_PACKET(vkCreateRenderPass, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkRenderPass));
// end custom code
- result = mdd(device)->devTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+ result = mdd(device)->devTable.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateRenderPass(pHeader);
pPacket->device = device;
@@ -435,12 +454,14 @@
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pPreserveAttachments), pSubpass->preserveAttachmentCount * sizeof(VkAttachmentReference), pSp->pPreserveAttachments);
vktrace_finalize_buffer_address(pHeader, (void**)&(pSubpass->pPreserveAttachments));
}
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPass), sizeof(VkRenderPass), pRenderPass);
pPacket->result = result;
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDependencies));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSubpasses));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPass));
FINISH_TRACE_PACKET();
return result;
@@ -861,6 +882,7 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines)
{
vktrace_trace_packet_header* pHeader;
@@ -872,7 +894,7 @@
total_size += get_struct_chain_size((void*)&pCreateInfos[i]);
}
CREATE_TRACE_PACKET(vkCreateGraphicsPipelines, total_size + createInfoCount*sizeof(VkPipeline));
- result = mdd(device)->devTable.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+ result = mdd(device)->devTable.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateGraphicsPipelines(pHeader);
pPacket->device = device;
@@ -880,9 +902,11 @@
pPacket->createInfoCount = createInfoCount;
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), createInfoCount*sizeof(VkGraphicsPipelineCreateInfo), pCreateInfos);
add_VkGraphicsPipelineCreateInfos_to_trace_packet(pHeader, (VkGraphicsPipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, createInfoCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), createInfoCount*sizeof(VkPipeline), pPipelines);
pPacket->result = result;
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
FINISH_TRACE_PACKET();
return result;
@@ -893,13 +917,14 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocCallbacks* pAllocator,
VkPipeline* pPipelines)
{
vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateComputePipelines* pPacket = NULL;
CREATE_TRACE_PACKET(vkCreateComputePipelines, createInfoCount*sizeof(VkComputePipelineCreateInfo) + sizeof(VkPipeline));
- result = mdd(device)->devTable.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+ result = mdd(device)->devTable.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateComputePipelines(pHeader);
pPacket->device = device;
@@ -907,9 +932,11 @@
pPacket->createInfoCount = createInfoCount;
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), createInfoCount*sizeof(VkComputePipelineCreateInfo), pCreateInfos);
add_VkComputePipelineCreateInfos_to_trace_packet(pHeader, (VkComputePipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, createInfoCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), createInfoCount*sizeof(VkPipeline), pPipelines);
pPacket->result = result;
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
FINISH_TRACE_PACKET();
return result;
diff --git a/vktrace/vktrace_generate.py b/vktrace/vktrace_generate.py
index ad5cc36..729f951 100755
--- a/vktrace/vktrace_generate.py
+++ b/vktrace/vktrace_generate.py
@@ -554,8 +554,6 @@
pid_enum.append('{')
pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkInstanceCreateInfo), pInStruct);')
pid_enum.append(' add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&((*ppStruct)->pAppInfo), pInStruct->pAppInfo);')
- pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAllocCb), sizeof(VkAllocCallbacks), pInStruct->pAllocCb);')
- pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAllocCb));')
# TODO138 : This is an initial pass at getting the extension/layer arrays correct, needs to be validated.
pid_enum.append(' uint32_t i, siz = 0;')
pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->enabledLayerNameCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
@@ -627,7 +625,6 @@
pid_enum.append(' if (pVkInstanceCreateInfo != NULL)')
pid_enum.append(' {')
pid_enum.append(' pVkInstanceCreateInfo->pAppInfo = (VkApplicationInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo);')
- pid_enum.append(' pVkInstanceCreateInfo->pAllocCb = (VkAllocCallbacks*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAllocCb);')
pid_enum.append(' VkApplicationInfo** ppAppInfo = (VkApplicationInfo**) &pVkInstanceCreateInfo->pAppInfo;')
pid_enum.append(' (*ppAppInfo)->pAppName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pAppName);')
pid_enum.append(' (*ppAppInfo)->pEngineName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pEngineName);')
@@ -1424,7 +1421,7 @@
ci_body.append(' {')
ci_body.append(' return vktrace_replay::VKTRACE_REPLAY_ERROR;')
ci_body.append(' }')
- ci_body.append(' replayResult = m_vkFuncs.real_vkCreateImage(remappedDevice, pPacket->pCreateInfo, &local_imageObj.replayImage);')
+ ci_body.append(' replayResult = m_vkFuncs.real_vkCreateImage(remappedDevice, pPacket->pCreateInfo, NULL, &local_imageObj.replayImage);')
ci_body.append(' if (replayResult == VK_SUCCESS)')
ci_body.append(' {')
ci_body.append(' m_objMapper.add_to_images_map(*(pPacket->pImage), local_imageObj);')
@@ -1439,7 +1436,7 @@
cb_body.append(' {')
cb_body.append(' return vktrace_replay::VKTRACE_REPLAY_ERROR;')
cb_body.append(' }')
- cb_body.append(' replayResult = m_vkFuncs.real_vkCreateBuffer(remappedDevice, pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
+ cb_body.append(' replayResult = m_vkFuncs.real_vkCreateBuffer(remappedDevice, pPacket->pCreateInfo, NULL, &local_bufferObj.replayBuffer);')
cb_body.append(' if (replayResult == VK_SUCCESS)')
cb_body.append(' {')
cb_body.append(' m_objMapper.add_to_buffers_map(*(pPacket->pBuffer), local_bufferObj);')
@@ -1644,7 +1641,8 @@
rr_string += ');'
elif create_view:
rr_list = rr_string.split(', ')
- rr_list[-2] = '&createInfo'
+ rr_list[-3] = '&createInfo'
+ rr_list[-2] = 'NULL'
rr_list[-1] = '&local_%s);' % proto.params[-1].name
rr_string = ', '.join(rr_list)
# this is a sneaky shortcut to use generic create code below to add_to_map
diff --git a/vulkan.py b/vulkan.py
index a57d199..3f0c706 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -213,10 +213,12 @@
protos=[
Proto("VkResult", "CreateInstance",
[Param("const VkInstanceCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkInstance*", "pInstance")]),
Proto("void", "DestroyInstance",
- [Param("VkInstance", "instance")]),
+ [Param("VkInstance", "instance"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "EnumeratePhysicalDevices",
[Param("VkInstance", "instance"),
@@ -265,10 +267,12 @@
Proto("VkResult", "CreateDevice",
[Param("VkPhysicalDevice", "physicalDevice"),
Param("const VkDeviceCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkDevice*", "pDevice")]),
Proto("void", "DestroyDevice",
- [Param("VkDevice", "device")]),
+ [Param("VkDevice", "device"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "EnumerateInstanceExtensionProperties",
[Param("const char*", "pLayerName"),
@@ -311,11 +315,13 @@
Proto("VkResult", "AllocMemory",
[Param("VkDevice", "device"),
Param("const VkMemoryAllocInfo*", "pAllocInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkDeviceMemory*", "pMem")]),
Proto("void", "FreeMemory",
[Param("VkDevice", "device"),
- Param("VkDeviceMemory", "mem")]),
+ Param("VkDeviceMemory", "mem"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "MapMemory",
[Param("VkDevice", "device"),
@@ -403,11 +409,13 @@
Proto("VkResult", "CreateFence",
[Param("VkDevice", "device"),
Param("const VkFenceCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkFence*", "pFence")]),
Proto("void", "DestroyFence",
[Param("VkDevice", "device"),
- Param("VkFence", "fence")]),
+ Param("VkFence", "fence"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "ResetFences",
[Param("VkDevice", "device"),
@@ -428,20 +436,24 @@
Proto("VkResult", "CreateSemaphore",
[Param("VkDevice", "device"),
Param("const VkSemaphoreCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkSemaphore*", "pSemaphore")]),
Proto("void", "DestroySemaphore",
[Param("VkDevice", "device"),
- Param("VkSemaphore", "semaphore")]),
+ Param("VkSemaphore", "semaphore"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateEvent",
[Param("VkDevice", "device"),
Param("const VkEventCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkEvent*", "pEvent")]),
Proto("void", "DestroyEvent",
[Param("VkDevice", "device"),
- Param("VkEvent", "event")]),
+ Param("VkEvent", "event"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "GetEventStatus",
[Param("VkDevice", "device"),
@@ -458,11 +470,13 @@
Proto("VkResult", "CreateQueryPool",
[Param("VkDevice", "device"),
Param("const VkQueryPoolCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkQueryPool*", "pQueryPool")]),
Proto("void", "DestroyQueryPool",
[Param("VkDevice", "device"),
- Param("VkQueryPool", "queryPool")]),
+ Param("VkQueryPool", "queryPool"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "GetQueryPoolResults",
[Param("VkDevice", "device"),
@@ -477,29 +491,35 @@
Proto("VkResult", "CreateBuffer",
[Param("VkDevice", "device"),
Param("const VkBufferCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkBuffer*", "pBuffer")]),
Proto("void", "DestroyBuffer",
[Param("VkDevice", "device"),
- Param("VkBuffer", "buffer")]),
+ Param("VkBuffer", "buffer"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateBufferView",
[Param("VkDevice", "device"),
Param("const VkBufferViewCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkBufferView*", "pView")]),
Proto("void", "DestroyBufferView",
[Param("VkDevice", "device"),
- Param("VkBufferView", "bufferView")]),
+ Param("VkBufferView", "bufferView"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateImage",
[Param("VkDevice", "device"),
Param("const VkImageCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkImage*", "pImage")]),
Proto("void", "DestroyImage",
[Param("VkDevice", "device"),
- Param("VkImage", "image")]),
+ Param("VkImage", "image"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("void", "GetImageSubresourceLayout",
[Param("VkDevice", "device"),
@@ -510,38 +530,46 @@
Proto("VkResult", "CreateImageView",
[Param("VkDevice", "device"),
Param("const VkImageViewCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkImageView*", "pView")]),
Proto("void", "DestroyImageView",
[Param("VkDevice", "device"),
- Param("VkImageView", "imageView")]),
+ Param("VkImageView", "imageView"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateShaderModule",
[Param("VkDevice", "device"),
Param("const VkShaderModuleCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkShaderModule*", "pShaderModule")]),
Proto("void", "DestroyShaderModule",
[Param("VkDevice", "device"),
- Param("VkShaderModule", "shaderModule")]),
+ Param("VkShaderModule", "shaderModule"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateShader",
[Param("VkDevice", "device"),
Param("const VkShaderCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkShader*", "pShader")]),
Proto("void", "DestroyShader",
[Param("VkDevice", "device"),
- Param("VkShader", "shader")]),
+ Param("VkShader", "shader"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreatePipelineCache",
[Param("VkDevice", "device"),
Param("const VkPipelineCacheCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkPipelineCache*", "pPipelineCache")]),
Proto("void", "DestroyPipelineCache",
[Param("VkDevice", "device"),
- Param("VkPipelineCache", "pipelineCache")]),
+ Param("VkPipelineCache", "pipelineCache"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "GetPipelineCacheData",
[Param("VkDevice", "device"),
@@ -560,6 +588,7 @@
Param("VkPipelineCache", "pipelineCache"),
Param("uint32_t", "createInfoCount"),
Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfos"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkPipeline*", "pPipelines")]),
Proto("VkResult", "CreateComputePipelines",
@@ -567,47 +596,57 @@
Param("VkPipelineCache", "pipelineCache"),
Param("uint32_t", "createInfoCount"),
Param("const VkComputePipelineCreateInfo*", "pCreateInfos"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkPipeline*", "pPipelines")]),
Proto("void", "DestroyPipeline",
[Param("VkDevice", "device"),
- Param("VkPipeline", "pipeline")]),
+ Param("VkPipeline", "pipeline"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreatePipelineLayout",
[Param("VkDevice", "device"),
Param("const VkPipelineLayoutCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkPipelineLayout*", "pPipelineLayout")]),
Proto("void", "DestroyPipelineLayout",
[Param("VkDevice", "device"),
- Param("VkPipelineLayout", "pipelineLayout")]),
+ Param("VkPipelineLayout", "pipelineLayout"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateSampler",
[Param("VkDevice", "device"),
Param("const VkSamplerCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkSampler*", "pSampler")]),
Proto("void", "DestroySampler",
[Param("VkDevice", "device"),
- Param("VkSampler", "sampler")]),
+ Param("VkSampler", "sampler"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateDescriptorSetLayout",
[Param("VkDevice", "device"),
Param("const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkDescriptorSetLayout*", "pSetLayout")]),
Proto("void", "DestroyDescriptorSetLayout",
[Param("VkDevice", "device"),
- Param("VkDescriptorSetLayout", "descriptorSetLayout")]),
+ Param("VkDescriptorSetLayout", "descriptorSetLayout"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateDescriptorPool",
[Param("VkDevice", "device"),
Param("const VkDescriptorPoolCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkDescriptorPool*", "pDescriptorPool")]),
Proto("void", "DestroyDescriptorPool",
[Param("VkDevice", "device"),
- Param("VkDescriptorPool", "descriptorPool")]),
+ Param("VkDescriptorPool", "descriptorPool"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "ResetDescriptorPool",
[Param("VkDevice", "device"),
@@ -635,20 +674,24 @@
Proto("VkResult", "CreateFramebuffer",
[Param("VkDevice", "device"),
Param("const VkFramebufferCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkFramebuffer*", "pFramebuffer")]),
Proto("void", "DestroyFramebuffer",
[Param("VkDevice", "device"),
- Param("VkFramebuffer", "framebuffer")]),
+ Param("VkFramebuffer", "framebuffer"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "CreateRenderPass",
[Param("VkDevice", "device"),
Param("const VkRenderPassCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkRenderPass*", "pRenderPass")]),
Proto("void", "DestroyRenderPass",
[Param("VkDevice", "device"),
- Param("VkRenderPass", "renderPass")]),
+ Param("VkRenderPass", "renderPass"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("void", "GetRenderAreaGranularity",
[Param("VkDevice", "device"),
@@ -658,11 +701,13 @@
Proto("VkResult", "CreateCommandPool",
[Param("VkDevice", "device"),
Param("const VkCmdPoolCreateInfo*", "pCreateInfo"),
+ Param("const VkAllocCallbacks*", "pAllocator"),
Param("VkCmdPool*", "pCmdPool")]),
Proto("void", "DestroyCommandPool",
[Param("VkDevice", "device"),
- Param("VkCmdPool", "cmdPool")]),
+ Param("VkCmdPool", "cmdPool"),
+ Param("const VkAllocCallbacks*", "pAllocator")]),
Proto("VkResult", "ResetCommandPool",
[Param("VkDevice", "device"),