diff options
| -rw-r--r-- | demos/cube.c | 125 | ||||
| -rw-r--r-- | demos/tri.c | 119 | ||||
| -rw-r--r-- | icd/common/icd-instance.c | 2 | ||||
| -rw-r--r-- | icd/common/icd-instance.h | 2 | ||||
| -rw-r--r-- | icd/nulldrv/nulldrv.c | 53 | ||||
| -rw-r--r-- | include/vkDbg.h | 11 | ||||
| -rw-r--r-- | include/vkLayer.h | 4 | ||||
| -rw-r--r-- | include/vk_platform.h | 12 | ||||
| -rw-r--r-- | include/vulkan.h | 205 | ||||
| -rw-r--r-- | layers/draw_state.cpp | 24 | ||||
| -rw-r--r-- | layers/glave_snapshot.c | 78 | ||||
| -rw-r--r-- | layers/layers_msg.h | 4 | ||||
| -rw-r--r-- | layers/mem_tracker.cpp | 54 | ||||
| -rw-r--r-- | layers/multi.cpp | 4 | ||||
| -rw-r--r-- | layers/param_checker.cpp | 84 | ||||
| -rw-r--r-- | loader/loader.c | 33 | ||||
| -rwxr-xr-x | vk-generate.py | 6 | ||||
| -rwxr-xr-x | vk-layer-generate.py | 6 | ||||
| -rwxr-xr-x | vulkan.py | 67 |
19 files changed, 533 insertions, 360 deletions
diff --git a/demos/cube.c b/demos/cube.c index 35882ed6..75b537aa 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -301,7 +301,7 @@ static void demo_flush_init_cmd(struct demo *demo) err = vkQueueWaitIdle(demo->queue); assert(!err); - vkDestroyObject(demo->cmd); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_COMMAND_BUFFER, demo->cmd); demo->cmd = VK_NULL_HANDLE; } @@ -474,8 +474,8 @@ static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf) err = vkEndCommandBuffer(cmd_buf); assert(!err); - vkDestroyObject(rp_begin.renderPass); - vkDestroyObject(rp_begin.framebuffer); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_RENDER_PASS, rp_begin.renderPass); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_FRAMEBUFFER, rp_begin.framebuffer); } @@ -494,12 +494,12 @@ void demo_update_data_buffer(struct demo *demo) mat4x4_mul(MVP, VP, demo->model_matrix); assert(demo->uniform_data.num_mem == 1); - err = vkMapMemory(demo->uniform_data.mem[0], 0, 0, 0, (void **) &pData); + err = vkMapMemory(demo->device, demo->uniform_data.mem[0], 0, 0, 0, (void **) &pData); assert(!err); memcpy(pData, (const void*) &MVP[0][0], matrixSize); - err = vkUnmapMemory(demo->uniform_data.mem[0]); + err = vkUnmapMemory(demo->device, demo->uniform_data.mem[0]); assert(!err); } @@ -614,6 +614,7 @@ static void demo_prepare_depth(struct demo *demo) .arraySize = 1, .flags = 0, }; + VkMemoryRequirements *mem_reqs; size_t mem_reqs_size = sizeof(VkMemoryRequirements); VkResult err; @@ -627,12 +628,16 @@ static void demo_prepare_depth(struct demo *demo) &demo->depth.image); assert(!err); - err = vkGetObjectInfo(demo->depth.image, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, demo->depth.image, + VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, + &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); demo->depth.mem = malloc(num_allocations * sizeof(VkDeviceMemory)); demo->depth.num_mem = num_allocations; - err = vkGetObjectInfo(demo->depth.image, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, demo->depth.image, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); @@ -645,8 +650,9 @@ static void demo_prepare_depth(struct demo *demo) assert(!err); /* bind memory */ - err = vkQueueBindObjectMemory(demo->queue, demo->depth.image, i, - demo->depth.mem[i], 0); + err = vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_IMAGE, demo->depth.image, + i, demo->depth.mem[i], 0); assert(!err); } @@ -858,13 +864,15 @@ static void demo_prepare_texture_image(struct demo *demo, &tex_obj->image); assert(!err); - err = vkGetObjectInfo(tex_obj->image, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, tex_obj->image, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); tex_obj->mem = malloc(num_allocations * sizeof(VkDeviceMemory)); - err = vkGetObjectInfo(tex_obj->image, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, tex_obj->image, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); @@ -878,7 +886,9 @@ static void demo_prepare_texture_image(struct demo *demo, assert(!err); /* bind memory */ - err = vkQueueBindObjectMemory(demo->queue, tex_obj->image, j, tex_obj->mem[j], 0); + err = vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_IMAGE, tex_obj->image, + j, tex_obj->mem[j], 0); assert(!err); } free(mem_reqs); @@ -896,21 +906,21 @@ static void demo_prepare_texture_image(struct demo *demo, size_t layout_size = sizeof(VkSubresourceLayout); void *data; - err = vkGetImageSubresourceInfo(tex_obj->image, &subres, + err = vkGetImageSubresourceInfo(demo->device, tex_obj->image, &subres, VK_SUBRESOURCE_INFO_TYPE_LAYOUT, &layout_size, &layout); assert(!err && layout_size == sizeof(layout)); /* Linear texture must be within a single memory object */ assert(num_allocations == 1); - err = vkMapMemory(tex_obj->mem[0], 0, 0, 0, &data); + err = vkMapMemory(demo->device, tex_obj->mem[0], 0, 0, 0, &data); assert(!err); if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) { fprintf(stderr, "Error loading texture: %s\n", filename); } - err = vkUnmapMemory(tex_obj->mem[0]); + err = vkUnmapMemory(demo->device, tex_obj->mem[0]); assert(!err); } @@ -925,12 +935,13 @@ static void demo_destroy_texture_image(struct demo *demo, struct texture_object { /* clean up staging resources */ for (uint32_t j = 0; j < tex_objs->num_mem; j ++) { - vkQueueBindObjectMemory(demo->queue, tex_objs->image, j, VK_NULL_HANDLE, 0); - vkFreeMemory(tex_objs->mem[j]); + vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_IMAGE, tex_objs->image, j, VK_NULL_HANDLE, 0); + vkFreeMemory(demo->device, tex_objs->mem[j]); } free(tex_objs->mem); - vkDestroyObject(tex_objs->image); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, tex_objs->image); } static void demo_prepare_textures(struct demo *demo) @@ -1087,14 +1098,16 @@ void demo_prepare_cube_data_buffer(struct demo *demo) err = vkCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf); assert(!err); - err = vkGetObjectInfo(demo->uniform_data.buf, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); demo->uniform_data.mem = malloc(num_allocations * sizeof(VkDeviceMemory)); demo->uniform_data.num_mem = num_allocations; - err = vkGetObjectInfo(demo->uniform_data.buf, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); assert(!err && mem_reqs_size == num_allocations * sizeof(*mem_reqs)); @@ -1104,16 +1117,17 @@ void demo_prepare_cube_data_buffer(struct demo *demo) err = vkAllocMemory(demo->device, &alloc_info, &(demo->uniform_data.mem[i])); assert(!err); - err = vkMapMemory(demo->uniform_data.mem[i], 0, 0, 0, (void **) &pData); + err = vkMapMemory(demo->device, demo->uniform_data.mem[i], 0, 0, 0, (void **) &pData); assert(!err); memcpy(pData, &data, (size_t)alloc_info.allocationSize); - err = vkUnmapMemory(demo->uniform_data.mem[i]); + err = vkUnmapMemory(demo->device, demo->uniform_data.mem[i]); assert(!err); - err = vkQueueBindObjectMemory(demo->queue, demo->uniform_data.buf, i, - demo->uniform_data.mem[i], 0); + err = vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf, + i, demo->uniform_data.mem[i], 0); assert(!err); } demo_add_mem_refs(demo, demo->uniform_data.num_mem, demo->uniform_data.mem); @@ -1362,13 +1376,13 @@ static void demo_prepare_pipeline(struct demo *demo) vs.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; vs.shader.stage = VK_SHADER_STAGE_VERTEX; vs.shader.shader = demo_prepare_vs(demo); - assert(vs.shader.shader != NULL); + assert(vs.shader.shader != VK_NULL_HANDLE); memset(&fs, 0, sizeof(fs)); fs.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; fs.shader.stage = VK_SHADER_STAGE_FRAGMENT; fs.shader.shader = demo_prepare_fs(demo); - assert(fs.shader.shader != NULL); + assert(fs.shader.shader != VK_NULL_HANDLE); memset(&ms, 0, sizeof(ms)); ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO; @@ -1388,8 +1402,8 @@ static void demo_prepare_pipeline(struct demo *demo) err = vkCreateGraphicsPipeline(demo->device, &pipeline, &demo->pipeline); assert(!err); - vkDestroyObject(vs.shader.shader); - vkDestroyObject(fs.shader.shader); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_SHADER, vs.shader.shader); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_SHADER, fs.shader.shader); } static void demo_prepare_dynamic_states(struct demo *demo) @@ -1514,7 +1528,7 @@ static void demo_prepare_descriptor_set(struct demo *demo) update_fs.count = DEMO_TEXTURE_COUNT; update_fs.pSamplerImageViews = combined_info; - err = vkAllocDescriptorSets(demo->desc_pool, + err = vkAllocDescriptorSets(demo->device, demo->desc_pool, VK_DESCRIPTOR_SET_USAGE_STATIC, 1, &demo->desc_layout, &demo->desc_set, &count); @@ -1523,8 +1537,8 @@ static void demo_prepare_descriptor_set(struct demo *demo) vkBeginDescriptorPoolUpdate(demo->device, VK_DESCRIPTOR_UPDATE_MODE_FASTEST); - vkClearDescriptorSets(demo->desc_pool, 1, &demo->desc_set); - vkUpdateDescriptors(demo->desc_set, 2, update_array); + vkClearDescriptorSets(demo->device, demo->desc_pool, 1, &demo->desc_set); + vkUpdateDescriptors(demo->device, demo->desc_set, 2, update_array); vkEndDescriptorPoolUpdate(demo->device, demo->buffers[demo->current_buffer].cmd); } @@ -1959,47 +1973,48 @@ static void demo_cleanup(struct demo *demo) { uint32_t i, j; - vkDestroyObject(demo->desc_set); - vkDestroyObject(demo->desc_pool); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET, demo->desc_set); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_POOL, demo->desc_pool); - vkDestroyObject(demo->viewport); - vkDestroyObject(demo->raster); - vkDestroyObject(demo->color_blend); - vkDestroyObject(demo->depth_stencil); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_VP_STATE, demo->viewport); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_RS_STATE, demo->raster); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_CB_STATE, demo->color_blend); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, demo->depth_stencil); - vkDestroyObject(demo->pipeline); - vkDestroyObject(demo->pipeline_layout); - vkDestroyObject(demo->desc_layout); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE, demo->pipeline); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE_LAYOUT, demo->pipeline_layout); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, demo->desc_layout); for (i = 0; i < DEMO_TEXTURE_COUNT; i++) { - vkDestroyObject(demo->textures[i].view); - vkQueueBindObjectMemory(demo->queue, demo->textures[i].image, 0, VK_NULL_HANDLE, 0); - vkDestroyObject(demo->textures[i].image); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE_VIEW, demo->textures[i].view); + vkQueueBindObjectMemory(demo->queue, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image, 0, VK_NULL_HANDLE, 0); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image); demo_remove_mem_refs(demo, demo->textures[i].num_mem, demo->textures[i].mem); for (j = 0; j < demo->textures[i].num_mem; j++) - vkFreeMemory(demo->textures[i].mem[j]); - vkDestroyObject(demo->textures[i].sampler); + vkFreeMemory(demo->device, demo->textures[i].mem[j]); + free(demo->textures[i].mem); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_SAMPLER, demo->textures[i].sampler); } vkDestroySwapChainWSI(demo->swap_chain); - vkDestroyObject(demo->depth.view); - vkQueueBindObjectMemory(demo->queue, demo->depth.image, 0, VK_NULL_HANDLE, 0); - vkDestroyObject(demo->depth.image); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, demo->depth.view); + vkQueueBindObjectMemory(demo->queue, VK_OBJECT_TYPE_IMAGE, demo->depth.image, 0, VK_NULL_HANDLE, 0); demo_remove_mem_refs(demo, demo->depth.num_mem, demo->depth.mem); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image); for (j = 0; j < demo->depth.num_mem; j++) { - vkFreeMemory(demo->depth.mem[j]); + vkFreeMemory(demo->device, demo->depth.mem[j]); } - vkDestroyObject(demo->uniform_data.view); - vkQueueBindObjectMemory(demo->queue, demo->uniform_data.buf, 0, VK_NULL_HANDLE, 0); - vkDestroyObject(demo->uniform_data.buf); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER_VIEW, demo->uniform_data.view); + vkQueueBindObjectMemory(demo->queue, VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf, 0, VK_NULL_HANDLE, 0); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf); demo_remove_mem_refs(demo, demo->uniform_data.num_mem, demo->uniform_data.mem); for (j = 0; j < demo->uniform_data.num_mem; j++) - vkFreeMemory(demo->uniform_data.mem[j]); + vkFreeMemory(demo->device, demo->uniform_data.mem[j]); for (i = 0; i < DEMO_BUFFER_COUNT; i++) { - vkDestroyObject(demo->buffers[i].view); - vkDestroyObject(demo->buffers[i].cmd); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, demo->buffers[i].view); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_COMMAND_BUFFER, demo->buffers[i].cmd); demo_remove_mem_refs(demo, 1, &demo->buffers[i].mem); } diff --git a/demos/tri.c b/demos/tri.c index f7217779..0621e3b3 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -129,7 +129,7 @@ static void demo_flush_init_cmd(struct demo *demo) err = vkQueueWaitIdle(demo->queue); assert(!err); - vkDestroyObject(demo->cmd); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_COMMAND_BUFFER, demo->cmd); demo->cmd = VK_NULL_HANDLE; } @@ -305,8 +305,8 @@ static void demo_draw_build_cmd(struct demo *demo) err = vkEndCommandBuffer(demo->cmd); assert(!err); - vkDestroyObject(rp_begin.renderPass); - vkDestroyObject(rp_begin.framebuffer); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_RENDER_PASS, rp_begin.renderPass); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_FRAMEBUFFER, rp_begin.framebuffer); } static void demo_draw(struct demo *demo) @@ -436,12 +436,16 @@ static void demo_prepare_depth(struct demo *demo) &demo->depth.image); assert(!err); - err = vkGetObjectInfo(demo->depth.image, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, demo->depth.image, + VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, + &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); demo->depth.mem = malloc(num_allocations * sizeof(VkDeviceMemory)); demo->depth.num_mem = num_allocations; - err = vkGetObjectInfo(demo->depth.image, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, demo->depth.image, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); @@ -454,8 +458,9 @@ static void demo_prepare_depth(struct demo *demo) assert(!err); /* bind memory */ - err = vkQueueBindObjectMemory(demo->queue, demo->depth.image, i, - demo->depth.mem[i], 0); + err = vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_IMAGE, demo->depth.image, + i, demo->depth.mem[i], 0); assert(!err); } @@ -516,13 +521,15 @@ static void demo_prepare_texture_image(struct demo *demo, &tex_obj->image); assert(!err); - err = vkGetObjectInfo(tex_obj->image, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, tex_obj->image, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); tex_obj->mem = malloc(num_allocations * sizeof(VkDeviceMemory)); - err = vkGetObjectInfo(tex_obj->image, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_IMAGE, tex_obj->image, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); @@ -536,7 +543,9 @@ static void demo_prepare_texture_image(struct demo *demo, assert(!err); /* bind memory */ - err = vkQueueBindObjectMemory(demo->queue, tex_obj->image, j, tex_obj->mem[j], 0); + err = vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_IMAGE, tex_obj->image, + j, tex_obj->mem[j], 0); assert(!err); } free(mem_reqs); @@ -555,14 +564,14 @@ static void demo_prepare_texture_image(struct demo *demo, void *data; int32_t x, y; - err = vkGetImageSubresourceInfo(tex_obj->image, &subres, + err = vkGetImageSubresourceInfo(demo->device, tex_obj->image, &subres, VK_SUBRESOURCE_INFO_TYPE_LAYOUT, &layout_size, &layout); assert(!err && layout_size == sizeof(layout)); /* Linear texture must be within a single memory object */ assert(num_allocations == 1); - err = vkMapMemory(tex_obj->mem[0], 0, 0, 0, &data); + err = vkMapMemory(demo->device, tex_obj->mem[0], 0, 0, 0, &data); assert(!err); for (y = 0; y < tex_height; y++) { @@ -571,7 +580,7 @@ static void demo_prepare_texture_image(struct demo *demo, row[x] = tex_colors[(x & 1) ^ (y & 1)]; } - err = vkUnmapMemory(tex_obj->mem[0]); + err = vkUnmapMemory(demo->device, tex_obj->mem[0]); assert(!err); } @@ -586,12 +595,13 @@ static void demo_destroy_texture_image(struct demo *demo, struct texture_object { /* clean up staging resources */ for (uint32_t j = 0; j < tex_obj->num_mem; j ++) { - vkQueueBindObjectMemory(demo->queue, tex_obj->image, j, VK_NULL_HANDLE, 0); - vkFreeMemory(tex_obj->mem[j]); + vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_IMAGE, tex_obj->image, j, VK_NULL_HANDLE, 0); + vkFreeMemory(demo->device, tex_obj->mem[j]); } free(tex_obj->mem); - vkDestroyObject(tex_obj->image); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, tex_obj->image); } static void demo_prepare_textures(struct demo *demo) @@ -739,14 +749,16 @@ static void demo_prepare_vertices(struct demo *demo) err = vkCreateBuffer(demo->device, &buf_info, &demo->vertices.buf); assert(!err); - err = vkGetObjectInfo(demo->vertices.buf, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_BUFFER, demo->vertices.buf, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); demo->vertices.mem = malloc(num_allocations * sizeof(VkDeviceMemory)); demo->vertices.num_mem = num_allocations; - err = vkGetObjectInfo(demo->vertices.buf, + err = vkGetObjectInfo(demo->device, + VK_OBJECT_TYPE_BUFFER, demo->vertices.buf, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); assert(!err && mem_reqs_size == sizeof(*mem_reqs)); @@ -756,15 +768,17 @@ static void demo_prepare_vertices(struct demo *demo) err = vkAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem[i]); assert(!err); - err = vkMapMemory(demo->vertices.mem[i], 0, 0, 0, &data); + err = vkMapMemory(demo->device, demo->vertices.mem[i], 0, 0, 0, &data); assert(!err); memcpy(data, vb, sizeof(vb)); - err = vkUnmapMemory(demo->vertices.mem[i]); + err = vkUnmapMemory(demo->device, demo->vertices.mem[i]); assert(!err); - err = vkQueueBindObjectMemory(demo->queue, demo->vertices.buf, i, demo->vertices.mem[i], 0); + err = vkQueueBindObjectMemory(demo->queue, + VK_OBJECT_TYPE_BUFFER, demo->vertices.buf, + i, demo->vertices.mem[i], 0); assert(!err); } @@ -852,7 +866,7 @@ static VkShader demo_prepare_shader(struct demo *demo, err = vkCreateShader(demo->device, &createInfo, &shader); if (err) { free((void *) createInfo.pCode); - return NULL; + return VK_NULL_HANDLE; } return shader; @@ -983,8 +997,8 @@ static void demo_prepare_pipeline(struct demo *demo) err = vkCreateGraphicsPipeline(demo->device, &pipeline, &demo->pipeline); assert(!err); - vkDestroyObject(vs.shader.shader); - vkDestroyObject(fs.shader.shader); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_SHADER, vs.shader.shader); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_SHADER, fs.shader.shader); } static void demo_prepare_dynamic_states(struct demo *demo) @@ -1094,7 +1108,7 @@ static void demo_prepare_descriptor_set(struct demo *demo) update.count = DEMO_TEXTURE_COUNT; update.pSamplerImageViews = combined_info; - err = vkAllocDescriptorSets(demo->desc_pool, + err = vkAllocDescriptorSets(demo->device, demo->desc_pool, VK_DESCRIPTOR_SET_USAGE_STATIC, 1, &demo->desc_layout, &demo->desc_set, &count); @@ -1103,8 +1117,8 @@ static void demo_prepare_descriptor_set(struct demo *demo) vkBeginDescriptorPoolUpdate(demo->device, VK_DESCRIPTOR_UPDATE_MODE_FASTEST); - vkClearDescriptorSets(demo->desc_pool, 1, &demo->desc_set); - vkUpdateDescriptors(demo->desc_set, 1, update_array); + vkClearDescriptorSets(demo->device, demo->desc_pool, 1, &demo->desc_set); + vkUpdateDescriptors(demo->device, demo->desc_set, 1, update_array); vkEndDescriptorPoolUpdate(demo->device, demo->cmd); } @@ -1391,7 +1405,7 @@ static void demo_init_vk(struct demo *demo) err = vkGetPhysicalDeviceInfo(demo->gpu, VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES, &data_size, demo->queue_props); assert(!err); - queue_count = (uint32_t) (data_size / sizeof(VkPhysicalDeviceQueueProperties)); + queue_count = (uint32_t) (data_size / sizeof(VkPhysicalDeviceQueueProperties)); assert(queue_count >= 1); for (i = 0; i < queue_count; i++) { @@ -1476,46 +1490,47 @@ static void demo_cleanup(struct demo *demo) { uint32_t i, j; - vkDestroyObject(demo->desc_set); - vkDestroyObject(demo->desc_pool); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET, demo->desc_set); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_POOL, demo->desc_pool); - vkDestroyObject(demo->cmd); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_COMMAND_BUFFER, demo->cmd); - vkDestroyObject(demo->viewport); - vkDestroyObject(demo->raster); - vkDestroyObject(demo->color_blend); - vkDestroyObject(demo->depth_stencil); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_VP_STATE, demo->viewport); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_RS_STATE, demo->raster); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_CB_STATE, demo->color_blend); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, demo->depth_stencil); - vkDestroyObject(demo->pipeline); - vkDestroyObject(demo->pipeline_layout); - vkDestroyObject(demo->desc_layout); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE, demo->pipeline); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE_LAYOUT, demo->pipeline_layout); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, demo->desc_layout); - vkQueueBindObjectMemory(demo->queue, demo->vertices.buf, 0, VK_NULL_HANDLE, 0); - vkDestroyObject(demo->vertices.buf); + vkQueueBindObjectMemory(demo->queue, VK_OBJECT_TYPE_BUFFER, demo->vertices.buf, 0, VK_NULL_HANDLE, 0); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER, demo->vertices.buf); demo_remove_mem_refs(demo, demo->vertices.num_mem, demo->vertices.mem); for (j = 0; j < demo->vertices.num_mem; j++) - vkFreeMemory(demo->vertices.mem[j]); + vkFreeMemory(demo->device, demo->vertices.mem[j]); for (i = 0; i < DEMO_TEXTURE_COUNT; i++) { - vkDestroyObject(demo->textures[i].view); - vkQueueBindObjectMemory(demo->queue, demo->textures[i].image, 0, VK_NULL_HANDLE, 0); - vkDestroyObject(demo->textures[i].image); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE_VIEW, demo->textures[i].view); + vkQueueBindObjectMemory(demo->queue, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image, 0, VK_NULL_HANDLE, 0); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image); demo_remove_mem_refs(demo, demo->textures[i].num_mem, demo->textures[i].mem); for (j = 0; j < demo->textures[i].num_mem; j++) - vkFreeMemory(demo->textures[i].mem[j]); + vkFreeMemory(demo->device, demo->textures[i].mem[j]); free(demo->textures[i].mem); - vkDestroyObject(demo->textures[i].sampler); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_SAMPLER, demo->textures[i].sampler); } - vkDestroyObject(demo->depth.view); - vkQueueBindObjectMemory(demo->queue, demo->depth.image, 0, VK_NULL_HANDLE, 0); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, demo->depth.view); + vkQueueBindObjectMemory(demo->queue, VK_OBJECT_TYPE_IMAGE, demo->depth.image, 0, VK_NULL_HANDLE, 0); demo_remove_mem_refs(demo, demo->depth.num_mem, demo->depth.mem); - vkDestroyObject(demo->depth.image); - for (j = 0; j < demo->depth.num_mem; j++) - vkFreeMemory(demo->depth.mem[j]); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image); + for (j = 0; j < demo->depth.num_mem; j++) { + vkFreeMemory(demo->device, demo->depth.mem[j]); + } for (i = 0; i < DEMO_BUFFER_COUNT; i++) { - vkDestroyObject(demo->buffers[i].view); + vkDestroyObject(demo->device, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, demo->buffers[i].view); demo_remove_mem_refs(demo, 1, &demo->buffers[i].mem); } vkDestroySwapChainWSI(demo->swap_chain); diff --git a/icd/common/icd-instance.c b/icd/common/icd-instance.c index 5a6e9f72..d83fac26 100644 --- a/icd/common/icd-instance.c +++ b/icd/common/icd-instance.c @@ -191,7 +191,7 @@ VkResult icd_instance_remove_logger(struct icd_instance *instance, void icd_instance_log(const struct icd_instance *instance, VK_DBG_MSG_TYPE msg_type, VkValidationLevel validation_level, - VkBaseObject src_object, + VkObject src_object, size_t location, int32_t msg_code, const char *msg) { diff --git a/icd/common/icd-instance.h b/icd/common/icd-instance.h index 13a146ba..45bbbc66 100644 --- a/icd/common/icd-instance.h +++ b/icd/common/icd-instance.h @@ -84,7 +84,7 @@ VkResult icd_instance_remove_logger(struct icd_instance *instance, void icd_instance_log(const struct icd_instance *instance, VK_DBG_MSG_TYPE msg_type, VkValidationLevel validation_level, - VkBaseObject src_object, + VkObject src_object, size_t location, int32_t msg_code, const char *msg); diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c index baa8ac17..dabe6685 100644 --- a/icd/nulldrv/nulldrv.c +++ b/icd/nulldrv/nulldrv.c @@ -43,7 +43,7 @@ static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = { [NULLDRV_EXT_WSI_LUNARG] = "VK_WSI_LunarG", }; -static struct nulldrv_base *nulldrv_base(VkBaseObject base) +static struct nulldrv_base *nulldrv_base(VkObject base) { return (struct nulldrv_base *) base; } @@ -1335,7 +1335,7 @@ ICD_EXPORT VkResult VKAPI vkGetDeviceQueue( { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); - *pQueue = dev->queues[0]; + *pQueue = (VkQueue) dev->queues[0]; return VK_SUCCESS; } @@ -1383,6 +1383,7 @@ ICD_EXPORT VkResult VKAPI vkCreateEvent( } ICD_EXPORT VkResult VKAPI vkGetEventStatus( + VkDevice device, VkEvent event_) { NULLDRV_LOG_FUNC; @@ -1390,6 +1391,7 @@ ICD_EXPORT VkResult VKAPI vkGetEventStatus( } ICD_EXPORT VkResult VKAPI vkSetEvent( + VkDevice device, VkEvent event_) { NULLDRV_LOG_FUNC; @@ -1397,6 +1399,7 @@ ICD_EXPORT VkResult VKAPI vkSetEvent( } ICD_EXPORT VkResult VKAPI vkResetEvent( + VkDevice device, VkEvent event_) { NULLDRV_LOG_FUNC; @@ -1416,6 +1419,7 @@ ICD_EXPORT VkResult VKAPI vkCreateFence( } ICD_EXPORT VkResult VKAPI vkGetFenceStatus( + VkDevice device, VkFence fence_) { NULLDRV_LOG_FUNC; @@ -1643,9 +1647,10 @@ ICD_EXPORT VkResult VKAPI vkCreateImage( } ICD_EXPORT VkResult VKAPI vkGetImageSubresourceInfo( - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceInfoType infoType, + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) { @@ -1687,6 +1692,7 @@ ICD_EXPORT VkResult VKAPI vkAllocMemory( } ICD_EXPORT VkResult VKAPI vkFreeMemory( + VkDevice device, VkDeviceMemory mem_) { NULLDRV_LOG_FUNC; @@ -1694,14 +1700,16 @@ ICD_EXPORT VkResult VKAPI vkFreeMemory( } ICD_EXPORT VkResult VKAPI vkSetMemoryPriority( + VkDevice device, VkDeviceMemory mem_, - VkMemoryPriority priority) + VkMemoryPriority priority) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } ICD_EXPORT VkResult VKAPI vkMapMemory( + VkDevice device, VkDeviceMemory mem_, VkDeviceSize offset, VkDeviceSize size, @@ -1718,6 +1726,7 @@ ICD_EXPORT VkResult VKAPI vkMapMemory( } ICD_EXPORT VkResult VKAPI vkUnmapMemory( + VkDevice device, VkDeviceMemory mem_) { NULLDRV_LOG_FUNC; @@ -1725,6 +1734,7 @@ ICD_EXPORT VkResult VKAPI vkUnmapMemory( } ICD_EXPORT VkResult VKAPI vkFlushMappedMemory( + VkDevice device, VkDeviceMemory mem_, VkDeviceSize offset, VkDeviceSize size) @@ -1775,7 +1785,7 @@ ICD_EXPORT VkResult VKAPI vkCreateInstance( inst->obj.base.get_info = NULL; - *pInstance = (VkInstance*)inst; + *pInstance = (VkInstance) inst; return VK_SUCCESS; } @@ -1842,6 +1852,8 @@ ICD_EXPORT VkResult VKAPI vkDbgSetGlobalOption( } ICD_EXPORT VkResult VKAPI vkDestroyObject( + VkDevice device, + VkObjectType objType, VkObject object) { NULLDRV_LOG_FUNC; @@ -1849,8 +1861,10 @@ ICD_EXPORT VkResult VKAPI vkDestroyObject( } ICD_EXPORT VkResult VKAPI vkGetObjectInfo( - VkBaseObject object, - VkObjectInfoType infoType, + VkDevice device, + VkObjectType objType, + VkObject object, + VkObjectInfoType infoType, size_t* pDataSize, void* pData) { @@ -1861,8 +1875,9 @@ ICD_EXPORT VkResult VKAPI vkGetObjectInfo( } ICD_EXPORT VkResult VKAPI vkQueueBindObjectMemory( - VkQueue queue, - VkObject object, + VkQueue queue, + VkObjectType objType, + VkObject object, uint32_t allocationIdx, VkDeviceMemory mem_, VkDeviceSize memOffset) @@ -1872,8 +1887,9 @@ ICD_EXPORT VkResult VKAPI vkQueueBindObjectMemory( } ICD_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange( - VkQueue queue, - VkObject object, + VkQueue queue, + VkObjectType objType, + VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, @@ -1897,7 +1913,8 @@ ICD_EXPORT VkResult VKAPI vkQueueBindImageMemoryRange( } ICD_EXPORT VkResult VKAPI vkDbgSetObjectTag( - VkBaseObject object, + VkDevice device, + VkObject object, size_t tagSize, const void* pTag) { @@ -1940,6 +1957,7 @@ ICD_EXPORT VkResult VKAPI vkCreateComputePipeline( } ICD_EXPORT VkResult VKAPI vkStorePipeline( + VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) @@ -1979,7 +1997,8 @@ ICD_EXPORT VkResult VKAPI vkCreateQueryPool( } ICD_EXPORT VkResult VKAPI vkGetQueryPoolResults( - VkQueryPool queryPool, + VkDevice device, + VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, @@ -2235,6 +2254,7 @@ ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool( } ICD_EXPORT VkResult VKAPI vkResetDescriptorPool( + VkDevice device, VkDescriptorPool descriptorPool) { NULLDRV_LOG_FUNC; @@ -2242,6 +2262,7 @@ ICD_EXPORT VkResult VKAPI vkResetDescriptorPool( } ICD_EXPORT VkResult VKAPI vkAllocDescriptorSets( + VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, @@ -2272,6 +2293,7 @@ ICD_EXPORT VkResult VKAPI vkAllocDescriptorSets( } ICD_EXPORT void VKAPI vkClearDescriptorSets( + VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) @@ -2280,6 +2302,7 @@ ICD_EXPORT void VKAPI vkClearDescriptorSets( } ICD_EXPORT void VKAPI vkUpdateDescriptors( + VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) diff --git a/include/vkDbg.h b/include/vkDbg.h index cc3c4255..f828eb8c 100644 --- a/include/vkDbg.h +++ b/include/vkDbg.h @@ -118,9 +118,9 @@ typedef enum _VK_DBG_OBJECT_TYPE } VK_DBG_OBJECT_TYPE; typedef void (VKAPI *VK_DBG_MSG_CALLBACK_FUNCTION)( - VK_DBG_MSG_TYPE msgType, - VkValidationLevel validationLevel, - VkBaseObject srcObject, + VK_DBG_MSG_TYPE msgType, + VkValidationLevel validationLevel, + VkObject srcObject, size_t location, int32_t msgCode, const char* pMsg, @@ -131,7 +131,7 @@ typedef VkResult (VKAPI *PFN_vkDbgSetValidationLevel)(VkDevice device, VkValidat typedef VkResult (VKAPI *PFN_vkDbgRegisterMsgCallback)(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData); typedef VkResult (VKAPI *PFN_vkDbgUnregisterMsgCallback)(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); typedef VkResult (VKAPI *PFN_vkDbgSetMessageFilter)(VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter); -typedef VkResult (VKAPI *PFN_vkDbgSetObjectTag)(VkBaseObject object, size_t tagSize, const void* pTag); +typedef VkResult (VKAPI *PFN_vkDbgSetObjectTag)(VkDevice device, VkObject object, size_t tagSize, const void* pTag); typedef VkResult (VKAPI *PFN_vkDbgSetGlobalOption)(VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData); typedef VkResult (VKAPI *PFN_vkDbgSetDeviceOption)(VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData); typedef void (VKAPI *PFN_vkCmdDbgMarkerBegin)(VkCmdBuffer cmdBuffer, const char* pMarker); @@ -157,7 +157,8 @@ VkResult VKAPI vkDbgSetMessageFilter( VK_DBG_MSG_FILTER filter); VkResult VKAPI vkDbgSetObjectTag( - VkBaseObject object, + VkDevice device, + VkObject object, size_t tagSize, const void* pTag); diff --git a/include/vkLayer.h b/include/vkLayer.h index 55fb3848..ec6e8acc 100644 --- a/include/vkLayer.h +++ b/include/vkLayer.h @@ -19,8 +19,8 @@ typedef struct VkBaseLayerObject_ { PFN_vkGetProcAddr pGPA; - VkBaseObject nextObject; - VkBaseObject baseObject; + VkObject nextObject; + VkObject baseObject; } VkBaseLayerObject; typedef struct VkLayerDispatchTable_ diff --git a/include/vk_platform.h b/include/vk_platform.h index 957c135e..90db1b2f 100644 --- a/include/vk_platform.h +++ b/include/vk_platform.h @@ -2,7 +2,7 @@ // File: vk_platform.h // /* -** Copyright (c) 2014 The Khronos Group Inc. +** Copyright (c) 2014-2015 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a ** copy of this software and/or associated documentation files (the @@ -82,6 +82,16 @@ typedef uint32_t bool32_t; typedef uint32_t VkSampleMask; typedef uint32_t VkFlags; +#if (UINTPTR_MAX >= UINT64_MAX) + #define VK_UINTPTRLEAST64_MAX UINTPTR_MAX + + typedef uintptr_t VkUintPtrLeast64; +#else + #define VK_UINTPTRLEAST64_MAX UINT64_MAX + + typedef uint64_t VkUintPtrLeast64; +#endif + #ifdef __cplusplus } // extern "C" #endif // __cplusplus diff --git a/include/vulkan.h b/include/vulkan.h index 98c32852..ef5ee5c4 100644 --- a/include/vulkan.h +++ b/include/vulkan.h @@ -33,7 +33,7 @@ #include "vk_platform.h" // Vulkan API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 84, 0) +#define VK_API_VERSION VK_MAKE_VERSION(0, 90, 0) #ifdef __cplusplus extern "C" @@ -46,49 +46,60 @@ extern "C" *************************************************************************************************** */ -#ifdef __cplusplus - #define VK_DEFINE_HANDLE(_obj) struct _obj##_T {char _dummy;}; typedef _obj##_T* _obj; - #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj; -#else // __cplusplus - #define VK_DEFINE_HANDLE(_obj) typedef void* _obj; - #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj; -#endif // __cplusplus - -VK_DEFINE_HANDLE(VkInstance) -VK_DEFINE_HANDLE(VkPhysicalDevice) -VK_DEFINE_HANDLE(VkBaseObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDevice, VkBaseObject) -VK_DEFINE_SUBCLASS_HANDLE(VkQueue, VkBaseObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDeviceMemory, VkBaseObject) -VK_DEFINE_SUBCLASS_HANDLE(VkObject, VkBaseObject) -VK_DEFINE_SUBCLASS_HANDLE(VkBuffer, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkBufferView, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkImage, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkImageView, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkColorAttachmentView, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDepthStencilView, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkShader, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkPipeline, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkPipelineLayout, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkSampler, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDescriptorSet, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDescriptorPool, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDynamicStateObject, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDynamicVpState, VkDynamicStateObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDynamicRsState, VkDynamicStateObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDynamicCbState, VkDynamicStateObject) -VK_DEFINE_SUBCLASS_HANDLE(VkDynamicDsState, VkDynamicStateObject) -VK_DEFINE_SUBCLASS_HANDLE(VkCmdBuffer, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkFence, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkSemaphore, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkEvent, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkQueryPool, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkFramebuffer, VkObject) -VK_DEFINE_SUBCLASS_HANDLE(VkRenderPass, VkObject) +#if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX) + #define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1 +#endif + +#if defined(VK_TYPE_SAFE_COMPATIBLE_HANDLES) && !defined(VK_DISABLE_TYPE_SAFE_HANDLES) + #define VK_DEFINE_PTR_HANDLE(_obj) struct _obj##_T { char _dummy; }; typedef _obj##_T* _obj; + #define VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj; + + #define VK_DEFINE_BASE_HANDLE(_obj) VK_DEFINE_PTR_HANDLE(_obj) + #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) + #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) +#else + #define VK_DEFINE_BASE_HANDLE(_obj) typedef VkUintPtrLeast64 _obj; + #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) typedef uintptr_t _obj; + #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) typedef VkUintPtrLeast64 _obj; +#endif + +VK_DEFINE_BASE_HANDLE(VkObject) + +VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance, VkObject) +VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice, VkObject) +VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice, VkObject) +VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue, VkObject) +VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer, VkObject) + +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable, VkObject) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicVpState, VkDynamicStateObject) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRsState, VkDynamicStateObject) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicCbState, VkDynamicStateObject) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDsState, VkDynamicStateObject) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable) #define VK_MAX_PHYSICAL_DEVICE_NAME 256 -#define VK_MAX_EXTENSION_NAME 256 +#define VK_MAX_EXTENSION_NAME 256 #define VK_LOD_CLAMP_NONE MAX_FLOAT #define VK_LAST_MIP_OR_SLICE 0xffffffff @@ -849,6 +860,46 @@ typedef enum VkStructureType_ VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, PIPELINE_LAYOUT_CREATE_INFO) } VkStructureType; +// Object type enumerant +typedef enum VkObjectType_ +{ + VK_OBJECT_TYPE_INSTANCE = 0, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1, + VK_OBJECT_TYPE_DEVICE = 2, + VK_OBJECT_TYPE_QUEUE = 3, + VK_OBJECT_TYPE_COMMAND_BUFFER = 4, + VK_OBJECT_TYPE_DEVICE_MEMORY = 5, + VK_OBJECT_TYPE_BUFFER = 6, + VK_OBJECT_TYPE_BUFFER_VIEW = 7, + VK_OBJECT_TYPE_IMAGE = 8, + VK_OBJECT_TYPE_IMAGE_VIEW = 9, + VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW = 10, + VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW = 11, + VK_OBJECT_TYPE_SHADER = 12, + VK_OBJECT_TYPE_PIPELINE = 13, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 14, + VK_OBJECT_TYPE_SAMPLER = 15, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 16, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 17, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 18, + VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 19, + VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 20, + VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 21, + VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 22, + VK_OBJECT_TYPE_FENCE = 23, + VK_OBJECT_TYPE_SEMAPHORE = 24, + VK_OBJECT_TYPE_EVENT = 25, + VK_OBJECT_TYPE_QUERY_POOL = 26, + VK_OBJECT_TYPE_FRAMEBUFFER = 27, + VK_OBJECT_TYPE_RENDER_PASS = 28, + + // Valid ranges for core Vulkan: + VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE, + VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_RENDER_PASS, + VK_NUM_OBJECT_TYPE = (VK_OBJECT_TYPE_END_RANGE - VK_OBJECT_TYPE_BEGIN_RANGE + 1), + VK_MAX_ENUM(VkObjectType) +} VkObjectType; + // ------------------------------------------------------------------------------------------------ // Error and return codes @@ -1302,7 +1353,7 @@ typedef struct VkInstanceCreateInfo_ } VkInstanceCreateInfo; // can be added to VkDeviceCreateInfo via pNext -typedef struct _VkLayerCreateInfo +typedef struct VkLayerCreateInfo_ { VkStructureType sType; // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO const void* pNext; // Pointer to next structure @@ -1355,6 +1406,7 @@ typedef struct VkMemoryRequirements_ VkDeviceSize granularity; // Granularity on which vkQueueBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) VkMemoryPropertyFlags memPropsAllowed; // Allowed memory property flags VkMemoryPropertyFlags memPropsRequired; // Required memory property flags + } VkMemoryRequirements; typedef struct VkFormatProperties_ @@ -1715,9 +1767,6 @@ typedef struct VkComputePipelineCreateInfo_ VkPipelineShader cs; VkPipelineCreateFlags flags; // Pipeline creation flags VkPipelineLayout layout; // Interface layout of the pipeline - uint32_t localSizeX; - uint32_t localSizeY; - uint32_t localSizeZ; } VkComputePipelineCreateInfo; typedef struct VkVertexInputBindingDescription_ @@ -2093,40 +2142,40 @@ typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReferences)(VkQueue queue, uint32_t typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkSetMemoryPriority)(VkDeviceMemory mem, VkMemoryPriority priority); -typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkFlushMappedMemory)(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size); +typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkSetMemoryPriority)(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority); +typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkFlushMappedMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size); typedef VkResult (VKAPI *PFN_vkPinSystemMemory)(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem); typedef VkResult (VKAPI *PFN_vkGetMultiDeviceCompatibility)(VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo); typedef VkResult (VKAPI *PFN_vkOpenSharedMemory)(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem); typedef VkResult (VKAPI *PFN_vkOpenSharedSemaphore)(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore); typedef VkResult (VKAPI *PFN_vkOpenPeerMemory)(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem); typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkObject object); -typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset); -typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object); +typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset); +typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset); typedef VkResult (VKAPI *PFN_vkQueueBindImageMemoryRange)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset); typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence* pFences); -typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkFence fence); +typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout); typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); -typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkEvent event); -typedef VkResult (VKAPI *PFN_vkSetEvent)(VkEvent event); -typedef VkResult (VKAPI *PFN_vkResetEvent)(VkEvent event); +typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); +typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); typedef VkResult (VKAPI *PFN_vkGetFormatInfo)(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData); typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); -typedef VkResult (VKAPI *PFN_vkGetImageSubresourceInfo)(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkGetImageSubresourceInfo)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData); typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView); typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView); @@ -2134,7 +2183,7 @@ typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCrea typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipeline)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline); typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelineDerivative)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline); typedef VkResult (VKAPI *PFN_vkCreateComputePipeline)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkStorePipeline)(VkPipeline pipeline, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkStorePipeline)(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData); typedef VkResult (VKAPI *PFN_vkLoadPipeline)(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline); typedef VkResult (VKAPI *PFN_vkLoadPipelineDerivative)(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline); typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); @@ -2143,10 +2192,10 @@ typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const typedef VkResult (VKAPI *PFN_vkBeginDescriptorPoolUpdate)(VkDevice device, VkDescriptorUpdateMode updateMode); typedef VkResult (VKAPI *PFN_vkEndDescriptorPoolUpdate)(VkDevice device, VkCmdBuffer cmd); typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); -typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); -typedef void (VKAPI *PFN_vkClearDescriptorSets)(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); -typedef void (VKAPI *PFN_vkUpdateDescriptors)(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray); +typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); +typedef void (VKAPI *PFN_vkClearDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI *PFN_vkUpdateDescriptors)(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray); typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState); typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState); typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState); @@ -2292,13 +2341,16 @@ VkResult VKAPI vkAllocMemory( VkDeviceMemory* pMem); VkResult VKAPI vkFreeMemory( + VkDevice device, VkDeviceMemory mem); VkResult VKAPI vkSetMemoryPriority( + VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority); VkResult VKAPI vkMapMemory( + VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, @@ -2306,9 +2358,11 @@ VkResult VKAPI vkMapMemory( void** ppData); VkResult VKAPI vkUnmapMemory( + VkDevice device, VkDeviceMemory mem); VkResult VKAPI vkFlushMappedMemory( + VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size); @@ -2350,10 +2404,14 @@ VkResult VKAPI vkOpenPeerImage( // Generic API object functions VkResult VKAPI vkDestroyObject( + VkDevice device, + VkObjectType objType, VkObject object); VkResult VKAPI vkGetObjectInfo( - VkBaseObject object, + VkDevice device, + VkObjectType objType, + VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData); @@ -2362,6 +2420,7 @@ VkResult VKAPI vkGetObjectInfo( VkResult VKAPI vkQueueBindObjectMemory( VkQueue queue, + VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, @@ -2369,6 +2428,7 @@ VkResult VKAPI vkQueueBindObjectMemory( VkResult VKAPI vkQueueBindObjectMemoryRange( VkQueue queue, + VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, @@ -2397,6 +2457,7 @@ VkResult VKAPI vkResetFences( VkFence* pFences); VkResult VKAPI vkGetFenceStatus( + VkDevice device, VkFence fence); VkResult VKAPI vkWaitForFences( @@ -2429,12 +2490,15 @@ VkResult VKAPI vkCreateEvent( VkEvent* pEvent); VkResult VKAPI vkGetEventStatus( + VkDevice device, VkEvent event); VkResult VKAPI vkSetEvent( + VkDevice device, VkEvent event); VkResult VKAPI vkResetEvent( + VkDevice device, VkEvent event); // Query functions @@ -2445,6 +2509,7 @@ VkResult VKAPI vkCreateQueryPool( VkQueryPool* pQueryPool); VkResult VKAPI vkGetQueryPoolResults( + VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, @@ -2483,6 +2548,7 @@ VkResult VKAPI vkCreateImage( VkImage* pImage); VkResult VKAPI vkGetImageSubresourceInfo( + VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, @@ -2532,6 +2598,7 @@ VkResult VKAPI vkCreateComputePipeline( VkPipeline* pPipeline); VkResult VKAPI vkStorePipeline( + VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData); @@ -2586,9 +2653,11 @@ VkResult VKAPI vkCreateDescriptorPool( VkDescriptorPool* pDescriptorPool); VkResult VKAPI vkResetDescriptorPool( + VkDevice device, VkDescriptorPool descriptorPool); VkResult VKAPI vkAllocDescriptorSets( + VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, @@ -2597,11 +2666,13 @@ VkResult VKAPI vkAllocDescriptorSets( uint32_t* pCount); void VKAPI vkClearDescriptorSets( + VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); void VKAPI vkUpdateDescriptors( + VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray); diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index 852eb915..aae865b8 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -1546,10 +1546,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCo return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object) { // TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory - VkResult result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(device, objType, object); return result; } @@ -1746,13 +1746,13 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescrip // Insert this pool into Global Pool LL at head char str[1024]; sprintf(str, "Created Descriptor Pool %p", (void*)*pDescriptorPool); - layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkBaseObject)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str); + layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str); loader_platform_thread_lock_mutex(&globalLock); POOL_NODE* pNewNode = new POOL_NODE; if (NULL == pNewNode) { char str[1024]; sprintf(str, "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()"); - layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VkBaseObject)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); + layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VkObject)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); } else { memset(pNewNode, 0, sizeof(POOL_NODE)); @@ -1777,18 +1777,18 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescrip return result; } -VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) { - VkResult result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(device, descriptorPool); if (VK_SUCCESS == result) { clearDescriptorPool(descriptorPool); } return result; } -VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { - VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); if ((VK_SUCCESS == result) || (*pCount > 0)) { POOL_NODE *pPoolNode = getPoolNode(descriptorPool); if (!pPoolNode) { @@ -1837,15 +1837,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptor return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { for (uint32_t i = 0; i < count; i++) { clearDescriptorSet(pDescriptorSets[i]); } - nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); + nextTable.ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { SET_NODE* pSet = getSetNode(descriptorSet); if (!dsUpdateActive(descriptorSet)) { @@ -1858,7 +1858,7 @@ VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, ui dsUpdate(descriptorSet, updateCount, ppUpdateArray); } - nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); + nextTable.UpdateDescriptors(device, descriptorSet, updateCount, ppUpdateArray); } VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c index b4a25076..81a2b588 100644 --- a/layers/glave_snapshot.c +++ b/layers/glave_snapshot.c @@ -610,41 +610,41 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllo return result; } -VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkGpuMemory mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkGpuMemory mem) { - VkResult result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(device, mem); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_object(&s_delta, (void*)mem); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkGpuMemory mem, VkMemoryPriority priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDevice device, VkGpuMemory mem, VkMemoryPriority priority) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(device, mem, priority); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkGpuMemory mem, VkFlags flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkGpuMemory mem, VkFlags flags, void** ppData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY); loader_platform_thread_unlock_mutex(&objLock); set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED); - VkResult result = nextTable.MapMemory(mem, flags, ppData); + VkResult result = nextTable.MapMemory(device, mem, flags, ppData); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkGpuMemory mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkGpuMemory mem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY); loader_platform_thread_unlock_mutex(&objLock); reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED); - VkResult result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(device, mem); return result; } @@ -705,39 +705,39 @@ VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImag return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object) { - VkResult result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(device, objType, object); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_object(&s_delta, (void*)object); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(device, objType, object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); + VkResult result = nextTable.BindObjectMemory(queue, objType, object, allocationIdx, mem, offset); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset, VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset, VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); + VkResult result = nextTable.BindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); return result; } @@ -766,13 +766,13 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreat return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)fence, VK_OBJECT_TYPE_FENCE); loader_platform_thread_unlock_mutex(&objLock); // Warn if submitted_flag is not set - VkResult result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(device, fence); return result; } @@ -829,30 +829,30 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreat return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkEvent event) +VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.GetEventStatus(event); + VkResult result = nextTable.GetEventStatus(device, event); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkEvent event) +VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkDevice device, VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.SetEvent(event); + VkResult result = nextTable.SetEvent(device, event); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkEvent event) +VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.ResetEvent(event); + VkResult result = nextTable.ResetEvent(device, event); return result; } @@ -872,12 +872,12 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryP return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)queryPool, VK_OBJECT_TYPE_QUERY_POOL); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); + VkResult result = nextTable.GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData); return result; } @@ -938,12 +938,12 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); + VkResult result = nextTable.GetImageSubresourceInfo(device, image, pSubresource, infoType, pDataSize, pData); return result; } @@ -1043,12 +1043,12 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const Vk return result; } -VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)pipeline, VK_OBJECT_TYPE_PIPELINE); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.StorePipeline(pipeline, pDataSize, pData); + VkResult result = nextTable.StorePipeline(device, pipeline, pDataSize, pData); return result; } @@ -1127,21 +1127,21 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescrip return result; } -VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(device, descriptorPool); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); loader_platform_thread_unlock_mutex(&objLock); - VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); if (result == VK_SUCCESS) { for (uint32_t i = 0; i < *pCount; i++) { @@ -1154,20 +1154,20 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptor return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); loader_platform_thread_unlock_mutex(&objLock); - nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); + nextTable.ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET); loader_platform_thread_unlock_mutex(&objLock); - nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); + nextTable.UpdateDescriptors(device, descriptorSet, updateCount, ppUpdateArray); } VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) @@ -1652,7 +1652,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t ms return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkBaseObject object, size_t tagSize, const void* pTag) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkObject object, size_t tagSize, const void* pTag) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); diff --git a/layers/layers_msg.h b/layers/layers_msg.h index cda11051..3cd5a0c2 100644 --- a/layers/layers_msg.h +++ b/layers/layers_msg.h @@ -33,8 +33,8 @@ static FILE *g_logFile = NULL; // Utility function to handle reporting // If callbacks are enabled, use them, otherwise use printf static void layerCbMsg(VK_DBG_MSG_TYPE msgType, - VkValidationLevel validationLevel, - VkBaseObject srcObject, + VkValidationLevel validationLevel, + VkObject srcObject, size_t location, int32_t msgCode, const char* pLayerPrefix, diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index bf0a325f..6f5eb39f 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -177,7 +177,7 @@ static void deleteFenceInfo(uint64_t fenceId) MT_FENCE_INFO* pDelInfo = fenceMap[fenceId]; if (pDelInfo != NULL) { if (pDelInfo->localFence == VK_TRUE) { - nextTable.DestroyObject(pDelInfo->fence); + nextTable.DestroyObject(globalDevice, VK_OBJECT_TYPE_FENCE, pDelInfo->fence); } delete pDelInfo; } @@ -1074,7 +1074,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllo return result; } -VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkDeviceMemory mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem) { /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before * freeing a memory object, an application must ensure the memory object is unbound from @@ -1090,19 +1090,19 @@ VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkDeviceMemory mem) printObjList(); printCBList(); loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(device, mem); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDeviceMemory mem, VkMemoryPriority priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) { // TODO : Update tracking for this alloc // Make sure memory is not pinned, which can't have priority set - VkResult result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(device, mem, priority); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) { // TODO : Track when memory is mapped loader_platform_thread_lock_mutex(&globalLock); @@ -1113,15 +1113,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkDeviceMemory mem, VkDeviceSize offs layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str); } loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = nextTable.MapMemory(mem, offset, size, flags, ppData); + VkResult result = nextTable.MapMemory(device, mem, offset, size, flags, ppData); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkDeviceMemory mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem) { // TODO : Track as memory gets unmapped, do we want to check what changed following map? // Make sure that memory was ever mapped to begin with - VkResult result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(device, mem); return result; } @@ -1154,7 +1154,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImag return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object) { loader_platform_thread_lock_mutex(&globalLock); @@ -1185,22 +1185,38 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) } loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(device, objType, object); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { // TODO : What to track here? // Could potentially save returned mem requirements and validate values passed into QueueBindObjectMemory for this object // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues, command buffers, shaders and memory objects. - VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(device, objType, object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset) +VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset) { - VkResult result = nextTable.QueueBindObjectMemory(queue, object, allocationIdx, mem, offset); + VkResult result = nextTable.QueueBindObjectMemory(queue, objType, object, allocationIdx, mem, offset); + loader_platform_thread_lock_mutex(&globalLock); + // Track objects tied to memory + if (VK_FALSE == updateObjectBinding(object, mem)) { + char str[1024]; + sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)object, (void*)mem); + layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str); + } + printObjList(); + printMemList(); + loader_platform_thread_unlock_mutex(&globalLock); + return result; +} + +VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) +{ + VkResult result = nextTable.QueueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); loader_platform_thread_lock_mutex(&globalLock); // Track objects tied to memory if (VK_FALSE == updateObjectBinding(object, mem)) { @@ -1252,9 +1268,9 @@ VK_LAYER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCoun return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence) { - VkResult result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(device, fence); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); updateFenceTracking(fence); @@ -2015,7 +2031,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(VkSwapChainWSI swapChain, V if (mismatch) { char str[1024]; sprintf(str, "vkGetSwapChainInfoWSI(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI) returned mismatching data", swapChain); - layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, (VkBaseObject) swapChain, 0, MEMTRACK_NONE, "SWAP_CHAIN", str); + layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, (VkObject) swapChain, 0, MEMTRACK_NONE, "SWAP_CHAIN", str); } } } @@ -2066,6 +2082,8 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* func return (void*) vkGetObjectInfo; if (!strcmp(funcName, "vkQueueBindObjectMemory")) return (void*) vkQueueBindObjectMemory; + if (!strcmp(funcName, "vkQueueBindObjectMemoryRange")) + return (void*) vkQueueBindObjectMemoryRange; if (!strcmp(funcName, "vkCreateFence")) return (void*) vkCreateFence; if (!strcmp(funcName, "vkGetFenceStatus")) diff --git a/layers/multi.cpp b/layers/multi.cpp index 3eb79c66..e70b6383 100644 --- a/layers/multi.cpp +++ b/layers/multi.cpp @@ -87,12 +87,12 @@ VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipeline(VkDevice device, con return result; } -VK_LAYER_EXPORT VkResult VKAPI multi1StorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI multi1StorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) { VkLayerDispatchTable* pTable = tableMap1[pipeline]; printf("At start of multi1 layer vkStorePipeline()\n"); - VkResult result = pTable->StorePipeline(pipeline, pDataSize, pData); + VkResult result = pTable->StorePipeline(device, pipeline, pDataSize, pData); printf("Completed multi1 layer vkStorePipeline()\n"); return result; } diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index b3eb1dc3..74d8582a 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -383,42 +383,42 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllo return result; } -VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkDeviceMemory mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem) { - VkResult result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(device, mem); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDeviceMemory mem, VkMemoryPriority priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) { char str[1024]; if (!validate_VkMemoryPriority(priority)) { sprintf(str, "Parameter priority to function SetMemoryPriority has invalid value of %i.", (int)priority); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VkResult result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(device, mem, priority); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) { - VkResult result = nextTable.MapMemory(mem, offset, size, flags, ppData); + VkResult result = nextTable.MapMemory(device, mem, offset, size, flags, ppData); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkDeviceMemory mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem) { - VkResult result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(device, mem); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkFlushMappedMemory(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) +VK_LAYER_EXPORT VkResult VKAPI vkFlushMappedMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) { - VkResult result = nextTable.FlushMappedMemory(mem, offset, size); + VkResult result = nextTable.FlushMappedMemory(device, mem, offset, size); return result; } @@ -498,35 +498,35 @@ VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImag return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object) { - VkResult result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(device, objType, object); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!validate_VkObjectInfoType(infoType)) { sprintf(str, "Parameter infoType to function GetObjectInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(device, objType, object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset) +VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset) { - VkResult result = nextTable.QueueBindObjectMemory(queue, object, allocationIdx, mem, offset); + VkResult result = nextTable.QueueBindObjectMemory(queue, objType, object, allocationIdx, mem, offset); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(VkQueue queue, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) { - VkResult result = nextTable.QueueBindObjectMemoryRange(queue, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); + VkResult result = nextTable.QueueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); return result; } @@ -560,10 +560,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreat return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence) { - VkResult result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(device, fence); return result; } @@ -625,24 +625,24 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreat return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkEvent event) +VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event) { - VkResult result = nextTable.GetEventStatus(event); + VkResult result = nextTable.GetEventStatus(device, event); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkEvent event) +VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkDevice device, VkEvent event) { - VkResult result = nextTable.SetEvent(event); + VkResult result = nextTable.SetEvent(device, event); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkEvent event) +VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event) { - VkResult result = nextTable.ResetEvent(event); + VkResult result = nextTable.ResetEvent(device, event); return result; } @@ -661,10 +661,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryP return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) +VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) { - VkResult result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData, flags); + VkResult result = nextTable.GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags); return result; } @@ -811,7 +811,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat return result; } -VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!pSubresource) { @@ -825,7 +825,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkImage image, const Vk sprintf(str, "Parameter infoType to function GetImageSubresourceInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VkResult result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); + VkResult result = nextTable.GetImageSubresourceInfo(device, image, pSubresource, infoType, pDataSize, pData); return result; } @@ -934,10 +934,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const Vk return result; } -VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) { - VkResult result = nextTable.StorePipeline(pipeline, pDataSize, pData); + VkResult result = nextTable.StorePipeline(device, pipeline, pDataSize, pData); return result; } @@ -1028,34 +1028,34 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescrip return result; } -VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) { - VkResult result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(device, descriptorPool); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { char str[1024]; if (!validate_VkDescriptorSetUsage(setUsage)) { sprintf(str, "Parameter setUsage to function AllocDescriptorSets has invalid value of %i.", (int)setUsage); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { - nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); + nextTable.ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { - nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); + nextTable.UpdateDescriptors(device, descriptorSet, updateCount, ppUpdateArray); } VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) @@ -1919,10 +1919,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t ms return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkBaseObject object, size_t tagSize, const void* pTag) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkDevice device, VkObject object, size_t tagSize, const void* pTag) { - VkResult result = nextTable.DbgSetObjectTag(object, tagSize, pTag); + VkResult result = nextTable.DbgSetObjectTag(device, object, tagSize, pTag); return result; } diff --git a/loader/loader.c b/loader/loader.c index 84a4e75a..a2d7cf7a 100644 --- a/loader/loader.c +++ b/loader/loader.c @@ -726,7 +726,7 @@ static void loader_init_dispatch_table(VkLayerDispatchTable *tab, PFN_vkGetProcA static void * VKAPI loader_gpa_internal(VkPhysicalDevice gpu, const char * pName) { - if (gpu == NULL) { + if (gpu == VK_NULL_HANDLE) { return NULL;; } VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu; @@ -756,8 +756,7 @@ extern struct loader_icd * loader_get_icd(const VkBaseLayerObject *gpu, uint32_t for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) { for (struct loader_icd *icd = inst->icds; icd; icd = icd->next) { for (uint32_t i = 0; i < icd->gpu_count; i++) - if ((icd->gpus + i) == gpu || (icd->gpus +i)->baseObject == - gpu) { + if ((icd->gpus + i) == gpu || (void*)(icd->gpus +i)->baseObject == gpu) { *gpu_index = i; return icd; } @@ -1023,7 +1022,7 @@ extern uint32_t loader_activate_layers(struct loader_icd *icd, uint32_t gpu_inde /* activate any layer libraries */ if (!loader_layers_activated(icd, gpu_index)) { VkBaseLayerObject *gpuObj = gpu; - VkBaseLayerObject *nextGpuObj, *baseObj = gpuObj->baseObject; + VkBaseLayerObject *nextGpuObj, *baseObj = (VkBaseLayerObject *) gpuObj->baseObject; PFN_vkGetProcAddr nextGPA = loader_gpa_internal; count = loader_get_layer_libs(icd, gpu_index, ext_count, ext_names, &pLayerNames); @@ -1037,8 +1036,8 @@ extern uint32_t loader_activate_layers(struct loader_icd *icd, uint32_t gpu_inde for (int32_t i = icd->layer_count[gpu_index] - 1; i >= 0; i--) { nextGpuObj = (icd->wrappedGpus[gpu_index] + i); nextGpuObj->pGPA = nextGPA; - nextGpuObj->baseObject = baseObj; - nextGpuObj->nextObject = gpuObj; + nextGpuObj->baseObject = (VkObject) baseObj; + nextGpuObj->nextObject = (VkObject) gpuObj; gpuObj = nextGpuObj; char funcStr[256]; @@ -1051,12 +1050,12 @@ extern uint32_t loader_activate_layers(struct loader_icd *icd, uint32_t gpu_inde } if (i == 0) { - loader_init_dispatch_table(icd->loader_dispatch + gpu_index, nextGPA, gpuObj); + loader_init_dispatch_table(icd->loader_dispatch + gpu_index, nextGPA, (VkPhysicalDevice) gpuObj); //Insert the new wrapped objects into the list with loader object at head - gpu->nextObject = gpuObj; + gpu->nextObject = (VkObject) gpuObj; gpu->pGPA = nextGPA; gpuObj = icd->wrappedGpus[gpu_index] + icd->layer_count[gpu_index] - 1; - gpuObj->nextObject = baseObj; + gpuObj->nextObject = (VkObject) baseObj; gpuObj->pGPA = icd->scanned_icds->GetProcAddr; } @@ -1128,7 +1127,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance( { ptr_instance->icds = ptr_instance->icds->next; loader_icd_destroy(icd); - scanned_icds->instance = NULL; + scanned_icds->instance = VK_NULL_HANDLE; loader_log(VK_DBG_MSG_WARNING, 0, "ICD ignored: failed to CreateInstance on device"); } @@ -1185,7 +1184,7 @@ LOADER_EXPORT VkResult VKAPI vkDestroyInstance( if (res != VK_SUCCESS) loader_log(VK_DBG_MSG_WARNING, 0, "ICD ignored: failed to DestroyInstance on device"); - scanned_icds->instance = NULL; + scanned_icds->instance = VK_NULL_HANDLE; scanned_icds = scanned_icds->next; } @@ -1253,7 +1252,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices( get_proc_addr, gpus[i]); /* Verify ICD compatibility */ - if (!valid_loader_magic_value(gpus[i])) { + if (!valid_loader_magic_value((void*) gpus[i])) { loader_log(VK_DBG_MSG_WARNING, 0, "Loader: Incompatible ICD, first dword must be initialized to ICD_LOADER_MAGIC. See loader/README.md for details.\n"); assert(0); @@ -1284,7 +1283,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices( LOADER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char * pName) { - if (gpu == NULL) { + if (gpu == VK_NULL_HANDLE) { /* return entrypoint addresses that are global (in the loader)*/ return globalGetProcAddr(pName); @@ -1422,7 +1421,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxL uint32_t n; VkResult res; n = (uint32_t) ((maxStringSize < 256) ? maxStringSize : 256); - res = fpEnumerateLayers(NULL, 16, n, &cnt, layers, (char *) icd->gpus + gpu_index); + res = fpEnumerateLayers((VkPhysicalDevice) NULL, 16, n, &cnt, layers, (char *) icd->gpus + gpu_index); loader_platform_close_library(handle); if (res != VK_SUCCESS) continue; @@ -1455,7 +1454,7 @@ LOADER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DB assert(loader.icds_scanned); for (inst = loader.instances; inst; inst = inst->next) { - if (inst == instance) + if ((VkInstance) inst == instance) break; } @@ -1503,7 +1502,7 @@ LOADER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_ assert(loader.icds_scanned); for (inst = loader.instances; inst; inst = inst->next) { - if (inst == instance) + if ((VkInstance) inst == instance) break; } @@ -1532,7 +1531,7 @@ LOADER_EXPORT VkResult VKAPI vkDbgSetGlobalOption(VkInstance instance, VK_DBG_GL assert(loader.icds_scanned); for (inst = loader.instances; inst; inst = inst->next) { - if (inst == instance) + if ((VkInstance) inst == instance) break; } diff --git a/vk-generate.py b/vk-generate.py index 550ebc1d..4204fcde 100755 --- a/vk-generate.py +++ b/vk-generate.py @@ -132,7 +132,7 @@ class LoaderEntrypointsSubcommand(Subcommand): pcount = proto.params[-1].name setup.append("uint32_t i;") setup.append("for (i = 0; i < *%s; i++)" % pcount) - setup.append(" %s(%s[i], disp);" % (method, psets)) + setup.append(" %s((void*)%s[i], disp);" % (method, psets)) elif proto.name == "GetPhysicalDeviceInfo": ptype = proto.params[-3].name psize = proto.params[-2].name @@ -159,7 +159,7 @@ class LoaderEntrypointsSubcommand(Subcommand): else: obj_params = proto.object_out_params() for param in obj_params: - setup.append("%s(*%s, disp);" % (method, param.name)) + setup.append("%s((void*)*%s, disp);" % (method, param.name)) if setup: joined = "\n ".join(setup) @@ -192,7 +192,7 @@ class LoaderEntrypointsSubcommand(Subcommand): func.append("") # get dispatch table - func.append(" disp = loader_get_data(%s);" % + func.append(" disp = loader_get_data((void*)%s);" % proto.params[0].name) func.append("") diff --git a/vk-layer-generate.py b/vk-layer-generate.py index 8bcc1325..ee9ce171 100755 --- a/vk-layer-generate.py +++ b/vk-layer-generate.py @@ -374,7 +374,7 @@ class Subcommand(object): "{\n" " VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;\n" " void* addr;\n" - " if (gpu == NULL)\n" + " if (gpu == VK_NULL_HANDLE)\n" " return NULL;\n" " pCurObj = gpuw;\n" " loader_platform_thread_once(&tabOnce, init%s);\n\n" @@ -481,7 +481,7 @@ class GenericLayerSubcommand(Subcommand): funcs.append('%s%s\n' '{\n' ' char str[1024];\n' - ' if (gpu != NULL) {\n' + ' if (gpu != VK_NULL_HANDLE) {\n' ' sprintf(str, "At start of layered %s\\n");\n' ' layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n' ' pCurObj = (VkBaseLayerObject *) gpu;\n' @@ -1133,7 +1133,7 @@ class ObjectTrackerSubcommand(Subcommand): return None obj_type_mapping = {base_t : base_t.replace("Vk", "VkObjectType") for base_t in vulkan.object_type_list} # For the various "super-types" we have to use function to distinguish sub type - for obj_type in ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT", "VkObject", "VkBaseObject"]: + for obj_type in ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT", "VkObject"]: obj_type_mapping[obj_type] = "ll_get_obj_type(object)" decl = proto.c_func(prefix="vk", attr="VKAPI") @@ -186,7 +186,6 @@ core = Extension( objects=[ "VkInstance", "VkPhysicalDevice", - "VkBaseObject", "VkDevice", "VkQueue", "VkDeviceMemory", @@ -303,24 +302,29 @@ core = Extension( Param("VkDeviceMemory*", "pMem")]), Proto("VkResult", "FreeMemory", - [Param("VkDeviceMemory", "mem")]), + [Param("VkDevice", "device"), + Param("VkDeviceMemory", "mem")]), Proto("VkResult", "SetMemoryPriority", - [Param("VkDeviceMemory", "mem"), + [Param("VkDevice", "device"), + Param("VkDeviceMemory", "mem"), Param("VkMemoryPriority", "priority")]), Proto("VkResult", "MapMemory", - [Param("VkDeviceMemory", "mem"), + [Param("VkDevice", "device"), + Param("VkDeviceMemory", "mem"), Param("VkDeviceSize", "offset"), Param("VkDeviceSize", "size"), Param("VkFlags", "flags"), Param("void**", "ppData")]), Proto("VkResult", "UnmapMemory", - [Param("VkDeviceMemory", "mem")]), + [Param("VkDevice", "device"), + Param("VkDeviceMemory", "mem")]), Proto("VkResult", "FlushMappedMemory", - [Param("VkDeviceMemory", "mem"), + [Param("VkDevice", "device"), + Param("VkDeviceMemory", "mem"), Param("VkDeviceSize", "offset"), Param("VkDeviceSize", "size")]), @@ -357,16 +361,21 @@ core = Extension( Param("VkDeviceMemory*", "pMem")]), Proto("VkResult", "DestroyObject", - [Param("VkObject", "object")]), + [Param("VkDevice", "device"), + Param("VkObjectType", "objType"), + Param("VkObject", "object")]), Proto("VkResult", "GetObjectInfo", - [Param("VkBaseObject", "object"), + [Param("VkDevice", "device"), + Param("VkObjectType", "objType"), + Param("VkObject", "object"), Param("VkObjectInfoType", "infoType"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), Proto("VkResult", "QueueBindObjectMemory", [Param("VkQueue", "queue"), + Param("VkObjectType", "objType"), Param("VkObject", "object"), Param("uint32_t", "allocationIdx"), Param("VkDeviceMemory", "mem"), @@ -374,6 +383,7 @@ core = Extension( Proto("VkResult", "QueueBindObjectMemoryRange", [Param("VkQueue", "queue"), + Param("VkObjectType", "objType"), Param("VkObject", "object"), Param("uint32_t", "allocationIdx"), Param("VkDeviceSize", "rangeOffset"), @@ -400,7 +410,8 @@ core = Extension( Param("VkFence*", "pFences")]), Proto("VkResult", "GetFenceStatus", - [Param("VkFence", "fence")]), + [Param("VkDevice", "device"), + Param("VkFence", "fence")]), Proto("VkResult", "WaitForFences", [Param("VkDevice", "device"), @@ -428,13 +439,16 @@ core = Extension( Param("VkEvent*", "pEvent")]), Proto("VkResult", "GetEventStatus", - [Param("VkEvent", "event")]), + [Param("VkDevice", "device"), + Param("VkEvent", "event")]), Proto("VkResult", "SetEvent", - [Param("VkEvent", "event")]), + [Param("VkDevice", "device"), + Param("VkEvent", "event")]), Proto("VkResult", "ResetEvent", - [Param("VkEvent", "event")]), + [Param("VkDevice", "device"), + Param("VkEvent", "event")]), Proto("VkResult", "CreateQueryPool", [Param("VkDevice", "device"), @@ -442,7 +456,8 @@ core = Extension( Param("VkQueryPool*", "pQueryPool")]), Proto("VkResult", "GetQueryPoolResults", - [Param("VkQueryPool", "queryPool"), + [Param("VkDevice", "device"), + Param("VkQueryPool", "queryPool"), Param("uint32_t", "startQuery"), Param("uint32_t", "queryCount"), Param("size_t*", "pDataSize"), @@ -472,7 +487,8 @@ core = Extension( Param("VkImage*", "pImage")]), Proto("VkResult", "GetImageSubresourceInfo", - [Param("VkImage", "image"), + [Param("VkDevice", "device"), + Param("VkImage", "image"), Param("const VkImageSubresource*", "pSubresource"), Param("VkSubresourceInfoType", "infoType"), Param("size_t*", "pDataSize"), @@ -515,7 +531,8 @@ core = Extension( Param("VkPipeline*", "pPipeline")]), Proto("VkResult", "StorePipeline", - [Param("VkPipeline", "pipeline"), + [Param("VkDevice", "device"), + Param("VkPipeline", "pipeline"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), @@ -563,10 +580,12 @@ core = Extension( Param("VkDescriptorPool*", "pDescriptorPool")]), Proto("VkResult", "ResetDescriptorPool", - [Param("VkDescriptorPool", "descriptorPool")]), + [Param("VkDevice", "device"), + Param("VkDescriptorPool", "descriptorPool")]), Proto("VkResult", "AllocDescriptorSets", - [Param("VkDescriptorPool", "descriptorPool"), + [Param("VkDevice", "device"), + Param("VkDescriptorPool", "descriptorPool"), Param("VkDescriptorSetUsage", "setUsage"), Param("uint32_t", "count"), Param("const VkDescriptorSetLayout*", "pSetLayouts"), @@ -574,12 +593,14 @@ core = Extension( Param("uint32_t*", "pCount")]), Proto("void", "ClearDescriptorSets", - [Param("VkDescriptorPool", "descriptorPool"), + [Param("VkDevice", "device"), + Param("VkDescriptorPool", "descriptorPool"), Param("uint32_t", "count"), Param("const VkDescriptorSet*", "pDescriptorSets")]), Proto("void", "UpdateDescriptors", - [Param("VkDescriptorSet", "descriptorSet"), + [Param("VkDevice", "device"), + Param("VkDescriptorSet", "descriptorSet"), Param("uint32_t", "updateCount"), Param("const void**", "ppUpdateArray")]), @@ -757,7 +778,7 @@ core = Extension( [Param("VkCmdBuffer", "cmdBuffer"), Param("VkImage", "image"), Param("VkImageLayout", "imageLayout"), - Param("VkClearColor", "color"), + Param("VkClearColor", "color"), Param("uint32_t", "rangeCount"), Param("const VkImageSubresourceRange*", "pRanges")]), @@ -898,7 +919,8 @@ core = Extension( Param("VK_DBG_MSG_FILTER", "filter")]), Proto("VkResult", "DbgSetObjectTag", - [Param("VkBaseObject", "object"), + [Param("VkDevice", "device"), + Param("VkObject", "object"), Param("size_t", "tagSize"), Param("const void*", "pTag")]), @@ -962,7 +984,6 @@ extensions = [core, wsi_lunarg] object_root_list = [ "VkInstance", "VkPhysicalDevice", - "VkBaseObject", "VkDisplayWSI", "VkSwapChainWSI", ] @@ -1007,7 +1028,7 @@ object_dynamic_state_list = [ object_type_list = object_root_list + object_base_list + object_list + object_dynamic_state_list -object_parent_list = ["VkBaseObject", "VkObject", "VkDynamicStateObject"] +object_parent_list = ["VkObject", "VkDynamicStateObject"] headers = [] objects = [] |