From 78351a69dfc6e3aca0490c4de282dc84d66db382 Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Fri, 10 Apr 2015 08:34:15 -0600 Subject: vulkan: beautification changes TODO: verify vk-layer-generate.py TODO: need to rename object tracker generator v2: fix "python3 vulkan.py" fix dead cod in tri introduced by rebase beautify wsi_null.c (olv) --- demos/cube.c | 320 +++--- demos/tri.c | 306 +++--- demos/vulkaninfo.c | 74 +- docs/vk_ds.dot | 20 +- docs/vk_full_pipeline_ds.dot | 72 +- docs/vk_graphics_pipeline.dot | 52 +- icd/README.md | 2 +- icd/common/icd-format.c | 20 +- icd/common/icd-format.h | 30 +- icd/common/icd-instance.c | 20 +- icd/common/icd-instance.h | 18 +- icd/nulldrv/nulldrv.c | 954 ++++++++--------- icd/nulldrv/nulldrv.h | 14 +- include/vkDbg.h | 56 +- include/vkLayer.h | 260 ++--- include/vkWsiX11Ext.h | 42 +- include/vk_platform.h | 6 +- include/vulkan.h | 2378 ++++++++++++++++++++--------------------- layers/basic.cpp | 36 +- layers/draw_state.cpp | 694 ++++++------ layers/draw_state.h | 106 +- layers/glave_snapshot.c | 424 ++++---- layers/glave_snapshot.h | 14 +- layers/layers_msg.h | 4 +- layers/mem_tracker.cpp | 526 ++++----- layers/mem_tracker.h | 44 +- layers/multi.cpp | 62 +- layers/object_track.h | 4 +- layers/param_checker.cpp | 560 +++++----- loader/loader.c | 86 +- loader/loader.h | 6 +- vk-generate.py | 10 +- vk-layer-generate.py | 76 +- vk_helper.py | 110 +- vulkan.py | 966 ++++++++--------- 35 files changed, 4184 insertions(+), 4188 deletions(-) diff --git a/demos/cube.c b/demos/cube.c index 80ed290d..5faae4bb 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -22,14 +22,14 @@ * structure to track all objects related to a texture. */ struct texture_object { - VK_SAMPLER sampler; + VkSampler sampler; - VK_IMAGE image; - VK_IMAGE_LAYOUT imageLayout; + VkImage image; + VkImageLayout imageLayout; uint32_t num_mem; - VK_GPU_MEMORY *mem; - VK_IMAGE_VIEW view; + VkGpuMemory *mem; + VkImageView view; int32_t tex_width, tex_height; }; @@ -202,55 +202,55 @@ struct demo { xcb_screen_t *screen; bool use_staging_buffer; - VK_INSTANCE inst; - VK_PHYSICAL_GPU gpu; - VK_DEVICE device; - VK_QUEUE queue; + VkInstance inst; + VkPhysicalGpu gpu; + VkDevice device; + VkQueue queue; uint32_t graphics_queue_node_index; - VK_PHYSICAL_GPU_PROPERTIES *gpu_props; - VK_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props; + VkPhysicalGpuProperties *gpu_props; + VkPhysicalGpuQueueProperties *queue_props; - VK_FRAMEBUFFER framebuffer; + VkFramebuffer framebuffer; int width, height; - VK_FORMAT format; + VkFormat format; struct { - VK_IMAGE image; - VK_GPU_MEMORY mem; - VK_CMD_BUFFER cmd; + VkImage image; + VkGpuMemory mem; + VkCmdBuffer cmd; - VK_COLOR_ATTACHMENT_VIEW view; - VK_FENCE fence; + VkColorAttachmentView view; + VkFence fence; } buffers[DEMO_BUFFER_COUNT]; struct { - VK_FORMAT format; + VkFormat format; - VK_IMAGE image; + VkImage image; uint32_t num_mem; - VK_GPU_MEMORY *mem; - VK_DEPTH_STENCIL_VIEW view; + VkGpuMemory *mem; + VkDepthStencilView view; } depth; struct texture_object textures[DEMO_TEXTURE_COUNT]; struct { - VK_BUFFER buf; + VkBuffer buf; uint32_t num_mem; - VK_GPU_MEMORY *mem; - VK_BUFFER_VIEW view; - VK_BUFFER_VIEW_ATTACH_INFO attach; + VkGpuMemory *mem; + VkBufferView view; + VkBufferViewAttachInfo attach; } uniform_data; - VK_CMD_BUFFER cmd; // Buffer for initialization commands - VK_DESCRIPTOR_SET_LAYOUT_CHAIN desc_layout_chain; - VK_DESCRIPTOR_SET_LAYOUT desc_layout; - VK_PIPELINE pipeline; + VkCmdBuffer cmd; // Buffer for initialization commands + VkDescriptorSetLayoutChain desc_layout_chain; + VkDescriptorSetLayout desc_layout; + VkPipeline pipeline; - VK_DYNAMIC_VP_STATE_OBJECT viewport; - VK_DYNAMIC_RS_STATE_OBJECT raster; - VK_DYNAMIC_CB_STATE_OBJECT color_blend; - VK_DYNAMIC_DS_STATE_OBJECT depth_stencil; + VkDynamicVpStateObject viewport; + VkDynamicRsStateObject raster; + VkDynamicCbStateObject color_blend; + VkDynamicDsStateObject depth_stencil; mat4x4 projection_matrix; mat4x4 view_matrix; @@ -260,8 +260,8 @@ struct demo { float spin_increment; bool pause; - VK_DESCRIPTOR_POOL desc_pool; - VK_DESCRIPTOR_SET desc_set; + VkDescriptorPool desc_pool; + VkDescriptorSet desc_set; xcb_window_t window; xcb_intern_atom_reply_t *atom_wm_delete_window; @@ -272,7 +272,7 @@ struct demo { static void demo_flush_init_cmd(struct demo *demo) { - VK_RESULT err; + VkResult err; if (demo->cmd == VK_NULL_HANDLE) return; @@ -280,7 +280,7 @@ static void demo_flush_init_cmd(struct demo *demo) err = vkEndCommandBuffer(demo->cmd); assert(!err); - const VK_CMD_BUFFER cmd_bufs[] = { demo->cmd }; + const VkCmdBuffer cmd_bufs[] = { demo->cmd }; err = vkQueueSubmit(demo->queue, 1, cmd_bufs, VK_NULL_HANDLE); assert(!err); @@ -294,7 +294,7 @@ static void demo_flush_init_cmd(struct demo *demo) static void demo_add_mem_refs( struct demo *demo, - int num_refs, VK_GPU_MEMORY *mem) + int num_refs, VkGpuMemory *mem) { for (int i = 0; i < num_refs; i++) { vkQueueAddMemReference(demo->queue, mem[i]); @@ -303,7 +303,7 @@ static void demo_add_mem_refs( static void demo_remove_mem_refs( struct demo *demo, - int num_refs, VK_GPU_MEMORY *mem) + int num_refs, VkGpuMemory *mem) { for (int i = 0; i < num_refs; i++) { vkQueueRemoveMemReference(demo->queue, mem[i]); @@ -312,14 +312,14 @@ static void demo_remove_mem_refs( static void demo_set_image_layout( struct demo *demo, - VK_IMAGE image, - VK_IMAGE_LAYOUT old_image_layout, - VK_IMAGE_LAYOUT new_image_layout) + VkImage image, + VkImageLayout old_image_layout, + VkImageLayout new_image_layout) { - VK_RESULT err; + VkResult err; if (demo->cmd == VK_NULL_HANDLE) { - const VK_CMD_BUFFER_CREATE_INFO cmd = { + const VkCmdBufferCreateInfo cmd = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, .pNext = NULL, .queueNodeIndex = demo->graphics_queue_node_index, @@ -329,7 +329,7 @@ static void demo_set_image_layout( err = vkCreateCommandBuffer(demo->device, &cmd, &demo->cmd); assert(!err); - VK_CMD_BUFFER_BEGIN_INFO cmd_buf_info = { + VkCmdBufferBeginInfo cmd_buf_info = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, .pNext = NULL, .flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT | @@ -338,7 +338,7 @@ static void demo_set_image_layout( err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info); } - VK_IMAGE_MEMORY_BARRIER image_memory_barrier = { + VkImageMemoryBarrier image_memory_barrier = { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .pNext = NULL, .outputMask = 0, @@ -359,11 +359,11 @@ static void demo_set_image_layout( image_memory_barrier.outputMask = VK_MEMORY_OUTPUT_COPY_BIT | VK_MEMORY_OUTPUT_CPU_WRITE_BIT; } - VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &image_memory_barrier; + VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier; - VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_TOP_OF_PIPE }; + VkPipeEvent set_events[] = { VK_PIPE_EVENT_TOP_OF_PIPE }; - VK_PIPELINE_BARRIER pipeline_barrier; + VkPipelineBarrier pipeline_barrier; pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER; pipeline_barrier.pNext = NULL; pipeline_barrier.eventCount = 1; @@ -375,44 +375,44 @@ static void demo_set_image_layout( vkCmdPipelineBarrier(demo->cmd, &pipeline_barrier); } -static void demo_draw_build_cmd(struct demo *demo, VK_CMD_BUFFER cmd_buf) +static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf) { - const VK_COLOR_ATTACHMENT_BIND_INFO color_attachment = { + const VkColorAttachmentBindInfo color_attachment = { .view = demo->buffers[demo->current_buffer].view, .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, }; - const VK_DEPTH_STENCIL_BIND_INFO depth_stencil = { + const VkDepthStencilBindInfo depth_stencil = { .view = demo->depth.view, .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }; - const VK_CLEAR_COLOR clear_color = { + const VkClearColor clear_color = { .color.floatColor = { 0.2f, 0.2f, 0.2f, 0.2f }, .useRawValue = false, }; const float clear_depth = 1.0f; - VK_IMAGE_SUBRESOURCE_RANGE clear_range; - VK_CMD_BUFFER_BEGIN_INFO cmd_buf_info = { + VkImageSubresourceRange clear_range; + VkCmdBufferBeginInfo cmd_buf_info = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, .pNext = NULL, .flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, }; - VK_RESULT err; - VK_ATTACHMENT_LOAD_OP load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - VK_ATTACHMENT_STORE_OP store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE; - const VK_FRAMEBUFFER_CREATE_INFO fb_info = { + VkResult err; + VkAttachmentLoadOp load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + VkAttachmentStoreOp store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE; + const VkFramebufferCreateInfo fb_info = { .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, .pNext = NULL, .colorAttachmentCount = 1, - .pColorAttachments = (VK_COLOR_ATTACHMENT_BIND_INFO*) &color_attachment, - .pDepthStencilAttachment = (VK_DEPTH_STENCIL_BIND_INFO*) &depth_stencil, + .pColorAttachments = (VkColorAttachmentBindInfo*) &color_attachment, + .pDepthStencilAttachment = (VkDepthStencilBindInfo*) &depth_stencil, .sampleCount = 1, .width = demo->width, .height = demo->height, .layers = 1, }; - VK_RENDER_PASS_CREATE_INFO rp_info; - VK_RENDER_PASS_BEGIN rp_begin; + VkRenderPassCreateInfo rp_info; + VkRenderPassBegin rp_begin; memset(&rp_info, 0 , sizeof(rp_info)); err = vkCreateFramebuffer(demo->device, &fb_info, &rp_begin.framebuffer); @@ -484,7 +484,7 @@ void demo_update_data_buffer(struct demo *demo) mat4x4 MVP, Model, VP; int matrixSize = sizeof(MVP); uint8_t *pData; - VK_RESULT err; + VkResult err; mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix); @@ -511,8 +511,8 @@ static void demo_draw(struct demo *demo) .async = true, .flip = false, }; - VK_FENCE fence = demo->buffers[demo->current_buffer].fence; - VK_RESULT err; + VkFence fence = demo->buffers[demo->current_buffer].fence; + VkResult err; err = vkWaitForFences(demo->device, 1, &fence, VK_TRUE, ~((uint64_t) 0)); assert(err == VK_SUCCESS || err == VK_ERROR_UNAVAILABLE); @@ -538,16 +538,16 @@ static void demo_prepare_buffers(struct demo *demo) }, .flags = 0, }; - const VK_FENCE_CREATE_INFO fence = { + const VkFenceCreateInfo fence = { .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = 0, }; - VK_RESULT err; + VkResult err; uint32_t i; for (i = 0; i < DEMO_BUFFER_COUNT; i++) { - VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO color_attachment_view = { + VkColorAttachmentViewCreateInfo color_attachment_view = { .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO, .pNext = NULL, .format = demo->format, @@ -580,8 +580,8 @@ static void demo_prepare_buffers(struct demo *demo) static void demo_prepare_depth(struct demo *demo) { - const VK_FORMAT depth_format = VK_FMT_D16_UNORM; - const VK_IMAGE_CREATE_INFO image = { + const VkFormat depth_format = VK_FMT_D16_UNORM; + const VkImageCreateInfo image = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = NULL, .imageType = VK_IMAGE_2D, @@ -606,7 +606,7 @@ static void demo_prepare_depth(struct demo *demo) .memType = VK_MEMORY_TYPE_IMAGE, .memPriority = VK_MEMORY_PRIORITY_NORMAL, }; - VK_DEPTH_STENCIL_VIEW_CREATE_INFO view = { + VkDepthStencilViewCreateInfo view = { .sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO, .pNext = NULL, .image = VK_NULL_HANDLE, @@ -615,11 +615,11 @@ static void demo_prepare_depth(struct demo *demo) .arraySize = 1, .flags = 0, }; - VK_MEMORY_REQUIREMENTS *mem_reqs; - size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS); - VK_IMAGE_MEMORY_REQUIREMENTS img_reqs; - size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS); - VK_RESULT err; + VkMemoryRequirements *mem_reqs; + size_t mem_reqs_size = sizeof(VkMemoryRequirements); + VkImageMemoryRequirements img_reqs; + size_t img_reqs_size = sizeof(VkImageMemoryRequirements); + VkResult err; uint32_t num_allocations = 0; size_t num_alloc_size = sizeof(num_allocations); @@ -632,17 +632,17 @@ static void demo_prepare_depth(struct demo *demo) err = vkGetObjectInfo(demo->depth.image, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); - mem_reqs = malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); - demo->depth.mem = malloc(num_allocations * sizeof(VK_GPU_MEMORY)); + mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); + demo->depth.mem = malloc(num_allocations * sizeof(VkGpuMemory)); demo->depth.num_mem = num_allocations; err = vkGetObjectInfo(demo->depth.image, VK_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); - assert(!err && mem_reqs_size == num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); + assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); err = vkGetObjectInfo(demo->depth.image, VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, &img_reqs_size, &img_reqs); - assert(!err && img_reqs_size == sizeof(VK_IMAGE_MEMORY_REQUIREMENTS)); + assert(!err && img_reqs_size == sizeof(VkImageMemoryRequirements)); img_alloc.usage = img_reqs.usage; img_alloc.formatClass = img_reqs.formatClass; img_alloc.samples = img_reqs.samples; @@ -689,7 +689,7 @@ static void demo_prepare_depth(struct demo *demo) * */ bool loadTexture(const char *filename, uint8_t *rgba_data, - VK_SUBRESOURCE_LAYOUT *layout, + VkSubresourceLayout *layout, int32_t *width, int32_t *height) { //header for testing if it is a png @@ -824,13 +824,13 @@ bool loadTexture(const char *filename, uint8_t *rgba_data, static void demo_prepare_texture_image(struct demo *demo, const char *filename, struct texture_object *tex_obj, - VK_IMAGE_TILING tiling, - VK_FLAGS mem_props) + VkImageTiling tiling, + VkFlags mem_props) { - const VK_FORMAT tex_format = VK_FMT_B8G8R8A8_UNORM; + const VkFormat tex_format = VK_FMT_B8G8R8A8_UNORM; int32_t tex_width; int32_t tex_height; - VK_RESULT err; + VkResult err; err = loadTexture(filename, NULL, NULL, &tex_width, &tex_height); assert(err); @@ -838,7 +838,7 @@ static void demo_prepare_texture_image(struct demo *demo, tex_obj->tex_width = tex_width; tex_obj->tex_height = tex_height; - const VK_IMAGE_CREATE_INFO image_create_info = { + const VkImageCreateInfo image_create_info = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = NULL, .imageType = VK_IMAGE_2D, @@ -868,12 +868,12 @@ static void demo_prepare_texture_image(struct demo *demo, .memPriority = VK_MEMORY_PRIORITY_NORMAL, }; - VK_MEMORY_REQUIREMENTS *mem_reqs; - size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS); - VK_BUFFER_MEMORY_REQUIREMENTS buf_reqs; - size_t buf_reqs_size = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS); - VK_IMAGE_MEMORY_REQUIREMENTS img_reqs; - size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS); + VkMemoryRequirements *mem_reqs; + size_t mem_reqs_size = sizeof(VkMemoryRequirements); + VkBufferMemoryRequirements buf_reqs; + size_t buf_reqs_size = sizeof(VkBufferMemoryRequirements); + VkImageMemoryRequirements img_reqs; + size_t img_reqs_size = sizeof(VkImageMemoryRequirements); uint32_t num_allocations = 0; size_t num_alloc_size = sizeof(num_allocations); @@ -885,16 +885,16 @@ static void demo_prepare_texture_image(struct demo *demo, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); - mem_reqs = malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); - tex_obj->mem = malloc(num_allocations * sizeof(VK_GPU_MEMORY)); + mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); + tex_obj->mem = malloc(num_allocations * sizeof(VkGpuMemory)); err = vkGetObjectInfo(tex_obj->image, VK_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); - assert(!err && mem_reqs_size == num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); + assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); err = vkGetObjectInfo(tex_obj->image, VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, &img_reqs_size, &img_reqs); - assert(!err && img_reqs_size == sizeof(VK_IMAGE_MEMORY_REQUIREMENTS)); + assert(!err && img_reqs_size == sizeof(VkImageMemoryRequirements)); img_alloc.usage = img_reqs.usage; img_alloc.formatClass = img_reqs.formatClass; img_alloc.samples = img_reqs.samples; @@ -907,7 +907,7 @@ static void demo_prepare_texture_image(struct demo *demo, err = vkGetObjectInfo(tex_obj->image, VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS, &buf_reqs_size, &buf_reqs); - assert(!err && buf_reqs_size == sizeof(VK_BUFFER_MEMORY_REQUIREMENTS)); + assert(!err && buf_reqs_size == sizeof(VkBufferMemoryRequirements)); buf_alloc.usage = buf_reqs.usage; img_alloc.pNext = &buf_alloc; } else { @@ -929,13 +929,13 @@ static void demo_prepare_texture_image(struct demo *demo, tex_obj->num_mem = num_allocations; if (mem_props & VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT) { - const VK_IMAGE_SUBRESOURCE subres = { + const VkImageSubresource subres = { .aspect = VK_IMAGE_ASPECT_COLOR, .mipLevel = 0, .arraySlice = 0, }; - VK_SUBRESOURCE_LAYOUT layout; - size_t layout_size = sizeof(VK_SUBRESOURCE_LAYOUT); + VkSubresourceLayout layout; + size_t layout_size = sizeof(VkSubresourceLayout); void *data; err = vkGetImageSubresourceInfo(tex_obj->image, &subres, @@ -977,10 +977,10 @@ static void demo_destroy_texture_image(struct texture_object *tex_objs) static void demo_prepare_textures(struct demo *demo) { - const VK_FORMAT tex_format = VK_FMT_R8G8B8A8_UNORM; - VK_FORMAT_PROPERTIES props; + const VkFormat tex_format = VK_FMT_R8G8B8A8_UNORM; + VkFormatProperties props; size_t size = sizeof(props); - VK_RESULT err; + VkResult err; uint32_t i; err = vkGetFormatInfo(demo->device, tex_format, @@ -1013,7 +1013,7 @@ static void demo_prepare_textures(struct demo *demo) demo->textures[i].imageLayout, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL); - VK_IMAGE_COPY copy_region = { + VkImageCopy copy_region = { .srcSubresource = { VK_IMAGE_ASPECT_COLOR, 0, 0 }, .srcOffset = { 0, 0, 0 }, .destSubresource = { VK_IMAGE_ASPECT_COLOR, 0, 0 }, @@ -1041,7 +1041,7 @@ static void demo_prepare_textures(struct demo *demo) assert(!"No support for tB8G8R8A8_UNORM as texture image format"); } - const VK_SAMPLER_CREATE_INFO sampler = { + const VkSamplerCreateInfo sampler = { .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, .pNext = NULL, .magFilter = VK_TEX_FILTER_NEAREST, @@ -1058,7 +1058,7 @@ static void demo_prepare_textures(struct demo *demo) .borderColorType = VK_BORDER_COLOR_OPAQUE_WHITE, }; - VK_IMAGE_VIEW_CREATE_INFO view = { + VkImageViewCreateInfo view = { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .pNext = NULL, .image = VK_NULL_HANDLE, @@ -1101,16 +1101,16 @@ void demo_prepare_cube_data_buffer(struct demo *demo) .memType = VK_MEMORY_TYPE_BUFFER, .memPriority = VK_MEMORY_PRIORITY_NORMAL, }; - VK_MEMORY_REQUIREMENTS *mem_reqs; - size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS); - VK_BUFFER_MEMORY_REQUIREMENTS buf_reqs; - size_t buf_reqs_size = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS); + VkMemoryRequirements *mem_reqs; + size_t mem_reqs_size = sizeof(VkMemoryRequirements); + VkBufferMemoryRequirements buf_reqs; + size_t buf_reqs_size = sizeof(VkBufferMemoryRequirements); uint32_t num_allocations = 0; size_t num_alloc_size = sizeof(num_allocations); uint8_t *pData; int i; mat4x4 MVP, VP; - VK_RESULT err; + VkResult err; struct vktexcube_vs_uniform data; mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix); @@ -1140,8 +1140,8 @@ void demo_prepare_cube_data_buffer(struct demo *demo) VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); - mem_reqs = malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); - demo->uniform_data.mem = malloc(num_allocations * sizeof(VK_GPU_MEMORY)); + mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); + demo->uniform_data.mem = malloc(num_allocations * sizeof(VkGpuMemory)); demo->uniform_data.num_mem = num_allocations; err = vkGetObjectInfo(demo->uniform_data.buf, VK_INFO_TYPE_MEMORY_REQUIREMENTS, @@ -1150,7 +1150,7 @@ void demo_prepare_cube_data_buffer(struct demo *demo) err = vkGetObjectInfo(demo->uniform_data.buf, VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS, &buf_reqs_size, &buf_reqs); - assert(!err && buf_reqs_size == sizeof(VK_BUFFER_MEMORY_REQUIREMENTS)); + assert(!err && buf_reqs_size == sizeof(VkBufferMemoryRequirements)); buf_alloc.usage = buf_reqs.usage; for (uint32_t i = 0; i < num_allocations; i ++) { alloc_info.allocationSize = mem_reqs[i].size; @@ -1188,7 +1188,7 @@ void demo_prepare_cube_data_buffer(struct demo *demo) static void demo_prepare_descriptor_layout(struct demo *demo) { - const VK_DESCRIPTOR_SET_LAYOUT_BINDING layout_bindings[2] = { + const VkDescriptorSetLayoutBinding layout_bindings[2] = { [0] = { .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .count = 1, @@ -1202,13 +1202,13 @@ static void demo_prepare_descriptor_layout(struct demo *demo) .pImmutableSamplers = NULL, }, }; - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO descriptor_layout = { + const VkDescriptorSetLayoutCreateInfo descriptor_layout = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, .pNext = NULL, .count = 2, .pBinding = layout_bindings, }; - VK_RESULT err; + VkResult err; err = vkCreateDescriptorSetLayout(demo->device, &descriptor_layout, &demo->desc_layout); @@ -1219,14 +1219,14 @@ static void demo_prepare_descriptor_layout(struct demo *demo) assert(!err); } -static VK_SHADER demo_prepare_shader(struct demo *demo, - VK_PIPELINE_SHADER_STAGE stage, +static VkShader demo_prepare_shader(struct demo *demo, + VkPipelineShaderStage stage, const void *code, size_t size) { - VK_SHADER_CREATE_INFO createInfo; - VK_SHADER shader; - VK_RESULT err; + VkShaderCreateInfo createInfo; + VkShader shader; + VkResult err; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO; @@ -1248,7 +1248,7 @@ static VK_SHADER demo_prepare_shader(struct demo *demo, createInfo.pCode = malloc(createInfo.codeSize); createInfo.flags = 0; - /* try version 0 first: VK_PIPELINE_SHADER_STAGE followed by GLSL */ + /* try version 0 first: VkPipelineShaderStage followed by GLSL */ ((uint32_t *) createInfo.pCode)[0] = ICD_SPV_MAGIC; ((uint32_t *) createInfo.pCode)[1] = 0; ((uint32_t *) createInfo.pCode)[2] = stage; @@ -1285,7 +1285,7 @@ char *demo_read_spv(const char *filename, size_t *psize) return shader_code; } -static VK_SHADER demo_prepare_vs(struct demo *demo) +static VkShader demo_prepare_vs(struct demo *demo) { #ifdef EXTERNAL_SPV void *vertShaderCode; @@ -1321,7 +1321,7 @@ static VK_SHADER demo_prepare_vs(struct demo *demo) #endif } -static VK_SHADER demo_prepare_fs(struct demo *demo) +static VkShader demo_prepare_fs(struct demo *demo) { #ifdef EXTERNAL_SPV void *fragShaderCode; @@ -1351,16 +1351,16 @@ static VK_SHADER demo_prepare_fs(struct demo *demo) static void demo_prepare_pipeline(struct demo *demo) { - VK_GRAPHICS_PIPELINE_CREATE_INFO pipeline; - VK_PIPELINE_IA_STATE_CREATE_INFO ia; - VK_PIPELINE_RS_STATE_CREATE_INFO rs; - VK_PIPELINE_CB_STATE_CREATE_INFO cb; - VK_PIPELINE_DS_STATE_CREATE_INFO ds; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO vs; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO fs; - VK_PIPELINE_VP_STATE_CREATE_INFO vp; - VK_PIPELINE_MS_STATE_CREATE_INFO ms; - VK_RESULT err; + VkGraphicsPipelineCreateInfo pipeline; + VkPipelineIaStateCreateInfo ia; + VkPipelineRsStateCreateInfo rs; + VkPipelineCbStateCreateInfo cb; + VkPipelineDsStateCreateInfo ds; + VkPipelineShaderStageCreateInfo vs; + VkPipelineShaderStageCreateInfo fs; + VkPipelineVpStateCreateInfo vp; + VkPipelineMsStateCreateInfo ms; + VkResult err; memset(&pipeline, 0, sizeof(pipeline)); pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; @@ -1378,7 +1378,7 @@ static void demo_prepare_pipeline(struct demo *demo) memset(&cb, 0, sizeof(cb)); cb.sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO; - VK_PIPELINE_CB_ATTACHMENT_STATE att_state[1]; + VkPipelineCbAttachmentState att_state[1]; memset(att_state, 0, sizeof(att_state)); att_state[0].format = demo->format; att_state[0].channelWriteMask = 0xf; @@ -1440,23 +1440,23 @@ static void demo_prepare_pipeline(struct demo *demo) static void demo_prepare_dynamic_states(struct demo *demo) { - VK_DYNAMIC_VP_STATE_CREATE_INFO viewport_create; - VK_DYNAMIC_RS_STATE_CREATE_INFO raster; - VK_DYNAMIC_CB_STATE_CREATE_INFO color_blend; - VK_DYNAMIC_DS_STATE_CREATE_INFO depth_stencil; - VK_RESULT err; + VkDynamicVpStateCreateInfo viewport_create; + VkDynamicRsStateCreateInfo raster; + VkDynamicCbStateCreateInfo color_blend; + VkDynamicDsStateCreateInfo depth_stencil; + VkResult err; memset(&viewport_create, 0, sizeof(viewport_create)); viewport_create.sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO; viewport_create.viewportAndScissorCount = 1; - VK_VIEWPORT viewport; + VkViewport viewport; memset(&viewport, 0, sizeof(viewport)); viewport.height = (float) demo->height; viewport.width = (float) demo->width; viewport.minDepth = (float) 0.0f; viewport.maxDepth = (float) 1.0f; viewport_create.pViewports = &viewport; - VK_RECT scissor; + VkRect scissor; memset(&scissor, 0, sizeof(scissor)); scissor.extent.width = demo->width; scissor.extent.height = demo->height; @@ -1502,7 +1502,7 @@ static void demo_prepare_dynamic_states(struct demo *demo) static void demo_prepare_descriptor_pool(struct demo *demo) { - const VK_DESCRIPTOR_TYPE_COUNT type_counts[2] = { + const VkDescriptorTypeCount type_counts[2] = { [0] = { .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .count = 1, @@ -1512,13 +1512,13 @@ static void demo_prepare_descriptor_pool(struct demo *demo) .count = DEMO_TEXTURE_COUNT, }, }; - const VK_DESCRIPTOR_POOL_CREATE_INFO descriptor_pool = { + const VkDescriptorPoolCreateInfo descriptor_pool = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, .pNext = NULL, .count = 2, .pTypeCount = type_counts, }; - VK_RESULT err; + VkResult err; err = vkCreateDescriptorPool(demo->device, VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, @@ -1528,12 +1528,12 @@ static void demo_prepare_descriptor_pool(struct demo *demo) static void demo_prepare_descriptor_set(struct demo *demo) { - VK_IMAGE_VIEW_ATTACH_INFO view_info[DEMO_TEXTURE_COUNT]; - VK_SAMPLER_IMAGE_VIEW_INFO combined_info[DEMO_TEXTURE_COUNT]; - VK_UPDATE_SAMPLER_TEXTURES update_fs; - VK_UPDATE_BUFFERS update_vs; + VkImageViewAttachInfo view_info[DEMO_TEXTURE_COUNT]; + VkSamplerImageViewInfo combined_info[DEMO_TEXTURE_COUNT]; + VkUpdateSamplerTextures update_fs; + VkUpdateBuffers update_vs; const void *update_array[2] = { &update_vs, &update_fs }; - VK_RESULT err; + VkResult err; uint32_t count; uint32_t i; @@ -1577,13 +1577,13 @@ static void demo_prepare_descriptor_set(struct demo *demo) static void demo_prepare(struct demo *demo) { - const VK_CMD_BUFFER_CREATE_INFO cmd = { + const VkCmdBufferCreateInfo cmd = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, .pNext = NULL, .queueNodeIndex = demo->graphics_queue_node_index, .flags = 0, }; - VK_RESULT err; + VkResult err; demo_prepare_buffers(demo); demo_prepare_depth(demo); @@ -1722,7 +1722,7 @@ static void demo_create_window(struct demo *demo) static void demo_init_vk(struct demo *demo) { - const VK_APPLICATION_INFO app = { + const VkApplicationInfo app = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pNext = NULL, .pAppName = "cube", @@ -1761,7 +1761,7 @@ static void demo_init_vk(struct demo *demo) .maxValidationLevel = VK_VALIDATION_LEVEL_END_RANGE, .flags = VK_DEVICE_CREATE_VALIDATION_BIT, }; - VK_RESULT err; + VkResult err; uint32_t gpu_count; uint32_t i; size_t data_size; @@ -1795,7 +1795,7 @@ static void demo_init_vk(struct demo *demo) &data_size, NULL); assert(!err); - demo->gpu_props = (VK_PHYSICAL_GPU_PROPERTIES *) malloc(data_size); + demo->gpu_props = (VkPhysicalGpuProperties *) malloc(data_size); err = vkGetGpuInfo(demo->gpu, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &data_size, demo->gpu_props); assert(!err); @@ -1804,11 +1804,11 @@ static void demo_init_vk(struct demo *demo) &data_size, NULL); assert(!err); - demo->queue_props = (VK_PHYSICAL_GPU_QUEUE_PROPERTIES *) malloc(data_size); + demo->queue_props = (VkPhysicalGpuQueueProperties *) malloc(data_size); err = vkGetGpuInfo(demo->gpu, VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, &data_size, demo->queue_props); assert(!err); - queue_count = (uint32_t)(data_size / sizeof(VK_PHYSICAL_GPU_QUEUE_PROPERTIES)); + queue_count = (uint32_t)(data_size / sizeof(VkPhysicalGpuQueueProperties)); assert(queue_count >= 1); for (i = 0; i < queue_count; i++) { diff --git a/demos/tri.c b/demos/tri.c index 91b8f0ed..f81ffbd6 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -22,14 +22,14 @@ #define VERTEX_BUFFER_BIND_ID 0 struct texture_object { - VK_SAMPLER sampler; + VkSampler sampler; - VK_IMAGE image; - VK_IMAGE_LAYOUT imageLayout; + VkImage image; + VkImageLayout imageLayout; uint32_t num_mem; - VK_GPU_MEMORY *mem; - VK_IMAGE_VIEW view; + VkGpuMemory *mem; + VkImageView view; int32_t tex_width, tex_height; }; @@ -37,58 +37,58 @@ struct demo { xcb_connection_t *connection; xcb_screen_t *screen; - VK_INSTANCE inst; - VK_PHYSICAL_GPU gpu; - VK_DEVICE device; - VK_QUEUE queue; - VK_PHYSICAL_GPU_PROPERTIES *gpu_props; - VK_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props; + VkInstance inst; + VkPhysicalGpu gpu; + VkDevice device; + VkQueue queue; + VkPhysicalGpuProperties *gpu_props; + VkPhysicalGpuQueueProperties *queue_props; uint32_t graphics_queue_node_index; int width, height; - VK_FORMAT format; + VkFormat format; struct { - VK_IMAGE image; - VK_GPU_MEMORY mem; + VkImage image; + VkGpuMemory mem; - VK_COLOR_ATTACHMENT_VIEW view; - VK_FENCE fence; + VkColorAttachmentView view; + VkFence fence; } buffers[DEMO_BUFFER_COUNT]; struct { - VK_FORMAT format; + VkFormat format; - VK_IMAGE image; + VkImage image; uint32_t num_mem; - VK_GPU_MEMORY *mem; - VK_DEPTH_STENCIL_VIEW view; + VkGpuMemory *mem; + VkDepthStencilView view; } depth; struct texture_object textures[DEMO_TEXTURE_COUNT]; struct { - VK_BUFFER buf; + VkBuffer buf; uint32_t num_mem; - VK_GPU_MEMORY *mem; + VkGpuMemory *mem; - VK_PIPELINE_VERTEX_INPUT_CREATE_INFO vi; - VK_VERTEX_INPUT_BINDING_DESCRIPTION vi_bindings[1]; - VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attrs[2]; + VkPipelineVertexInputCreateInfo vi; + VkVertexInputBindingDescription vi_bindings[1]; + VkVertexInputAttributeDescription vi_attrs[2]; } vertices; - VK_CMD_BUFFER cmd; // Buffer for initialization commands - VK_DESCRIPTOR_SET_LAYOUT_CHAIN desc_layout_chain; - VK_DESCRIPTOR_SET_LAYOUT desc_layout; - VK_PIPELINE pipeline; + VkCmdBuffer cmd; // Buffer for initialization commands + VkDescriptorSetLayoutChain desc_layout_chain; + VkDescriptorSetLayout desc_layout; + VkPipeline pipeline; - VK_DYNAMIC_VP_STATE_OBJECT viewport; - VK_DYNAMIC_RS_STATE_OBJECT raster; - VK_DYNAMIC_CB_STATE_OBJECT color_blend; - VK_DYNAMIC_DS_STATE_OBJECT depth_stencil; + VkDynamicVpStateObject viewport; + VkDynamicRsStateObject raster; + VkDynamicCbStateObject color_blend; + VkDynamicDsStateObject depth_stencil; - VK_DESCRIPTOR_POOL desc_pool; - VK_DESCRIPTOR_SET desc_set; + VkDescriptorPool desc_pool; + VkDescriptorSet desc_set; xcb_window_t window; xcb_intern_atom_reply_t *atom_wm_delete_window; @@ -100,7 +100,7 @@ struct demo { static void demo_flush_init_cmd(struct demo *demo) { - VK_RESULT err; + VkResult err; if (demo->cmd == VK_NULL_HANDLE) return; @@ -108,7 +108,7 @@ static void demo_flush_init_cmd(struct demo *demo) err = vkEndCommandBuffer(demo->cmd); assert(!err); - const VK_CMD_BUFFER cmd_bufs[] = { demo->cmd }; + const VkCmdBuffer cmd_bufs[] = { demo->cmd }; err = vkQueueSubmit(demo->queue, 1, cmd_bufs, VK_NULL_HANDLE); assert(!err); @@ -122,7 +122,7 @@ static void demo_flush_init_cmd(struct demo *demo) static void demo_add_mem_refs( struct demo *demo, - int num_refs, VK_GPU_MEMORY *mem) + int num_refs, VkGpuMemory *mem) { for (int i = 0; i < num_refs; i++) { vkQueueAddMemReference(demo->queue, mem[i]); @@ -131,7 +131,7 @@ static void demo_add_mem_refs( static void demo_remove_mem_refs( struct demo *demo, - int num_refs, VK_GPU_MEMORY *mem) + int num_refs, VkGpuMemory *mem) { for (int i = 0; i < num_refs; i++) { vkQueueRemoveMemReference(demo->queue, mem[i]); @@ -140,14 +140,14 @@ static void demo_remove_mem_refs( static void demo_set_image_layout( struct demo *demo, - VK_IMAGE image, - VK_IMAGE_LAYOUT old_image_layout, - VK_IMAGE_LAYOUT new_image_layout) + VkImage image, + VkImageLayout old_image_layout, + VkImageLayout new_image_layout) { - VK_RESULT err; + VkResult err; if (demo->cmd == VK_NULL_HANDLE) { - const VK_CMD_BUFFER_CREATE_INFO cmd = { + const VkCmdBufferCreateInfo cmd = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, .pNext = NULL, .queueNodeIndex = demo->graphics_queue_node_index, @@ -157,7 +157,7 @@ static void demo_set_image_layout( err = vkCreateCommandBuffer(demo->device, &cmd, &demo->cmd); assert(!err); - VK_CMD_BUFFER_BEGIN_INFO cmd_buf_info = { + VkCmdBufferBeginInfo cmd_buf_info = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, .pNext = NULL, .flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT | @@ -166,7 +166,7 @@ static void demo_set_image_layout( err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info); } - VK_IMAGE_MEMORY_BARRIER image_memory_barrier = { + VkImageMemoryBarrier image_memory_barrier = { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .pNext = NULL, .outputMask = 0, @@ -187,11 +187,11 @@ static void demo_set_image_layout( image_memory_barrier.outputMask = VK_MEMORY_OUTPUT_COPY_BIT | VK_MEMORY_OUTPUT_CPU_WRITE_BIT; } - VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &image_memory_barrier; + VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier; - VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_TOP_OF_PIPE }; + VkPipeEvent set_events[] = { VK_PIPE_EVENT_TOP_OF_PIPE }; - VK_PIPELINE_BARRIER pipeline_barrier; + VkPipelineBarrier pipeline_barrier; pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER; pipeline_barrier.pNext = NULL; pipeline_barrier.eventCount = 1; @@ -205,42 +205,42 @@ static void demo_set_image_layout( static void demo_draw_build_cmd(struct demo *demo) { - const VK_COLOR_ATTACHMENT_BIND_INFO color_attachment = { + const VkColorAttachmentBindInfo color_attachment = { .view = demo->buffers[demo->current_buffer].view, .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, }; - const VK_DEPTH_STENCIL_BIND_INFO depth_stencil = { + const VkDepthStencilBindInfo depth_stencil = { .view = demo->depth.view, .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }; - const VK_CLEAR_COLOR clear_color = { + const VkClearColor clear_color = { .color.floatColor = { 0.2f, 0.2f, 0.2f, 0.2f }, .useRawValue = false, }; const float clear_depth = 0.9f; - VK_IMAGE_SUBRESOURCE_RANGE clear_range; - VK_CMD_BUFFER_BEGIN_INFO cmd_buf_info = { + VkImageSubresourceRange clear_range; + VkCmdBufferBeginInfo cmd_buf_info = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, .pNext = NULL, .flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, }; - VK_RESULT err; - VK_ATTACHMENT_LOAD_OP load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - VK_ATTACHMENT_STORE_OP store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE; - const VK_FRAMEBUFFER_CREATE_INFO fb_info = { + VkResult err; + VkAttachmentLoadOp load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + VkAttachmentStoreOp store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE; + const VkFramebufferCreateInfo fb_info = { .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, .pNext = NULL, .colorAttachmentCount = 1, - .pColorAttachments = (VK_COLOR_ATTACHMENT_BIND_INFO*) &color_attachment, - .pDepthStencilAttachment = (VK_DEPTH_STENCIL_BIND_INFO*) &depth_stencil, + .pColorAttachments = (VkColorAttachmentBindInfo*) &color_attachment, + .pDepthStencilAttachment = (VkDepthStencilBindInfo*) &depth_stencil, .sampleCount = 1, .width = demo->width, .height = demo->height, .layers = 1, }; - VK_RENDER_PASS_CREATE_INFO rp_info; - VK_RENDER_PASS_BEGIN rp_begin; + VkRenderPassCreateInfo rp_info; + VkRenderPassBegin rp_begin; memset(&rp_info, 0 , sizeof(rp_info)); err = vkCreateFramebuffer(demo->device, &fb_info, &rp_begin.framebuffer); @@ -315,8 +315,8 @@ static void demo_draw(struct demo *demo) .destWindow = demo->window, .srcImage = demo->buffers[demo->current_buffer].image, }; - VK_FENCE fence = demo->buffers[demo->current_buffer].fence; - VK_RESULT err; + VkFence fence = demo->buffers[demo->current_buffer].fence; + VkResult err; demo_draw_build_cmd(demo); @@ -343,16 +343,16 @@ static void demo_prepare_buffers(struct demo *demo) }, .flags = 0, }; - const VK_FENCE_CREATE_INFO fence = { + const VkFenceCreateInfo fence = { .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = 0, }; - VK_RESULT err; + VkResult err; uint32_t i; for (i = 0; i < DEMO_BUFFER_COUNT; i++) { - VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO color_attachment_view = { + VkColorAttachmentViewCreateInfo color_attachment_view = { .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO, .pNext = NULL, .format = demo->format, @@ -385,8 +385,8 @@ static void demo_prepare_buffers(struct demo *demo) static void demo_prepare_depth(struct demo *demo) { - const VK_FORMAT depth_format = VK_FMT_D16_UNORM; - const VK_IMAGE_CREATE_INFO image = { + const VkFormat depth_format = VK_FMT_D16_UNORM; + const VkImageCreateInfo image = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = NULL, .imageType = VK_IMAGE_2D, @@ -411,7 +411,7 @@ static void demo_prepare_depth(struct demo *demo) .memType = VK_MEMORY_TYPE_IMAGE, .memPriority = VK_MEMORY_PRIORITY_NORMAL, }; - VK_DEPTH_STENCIL_VIEW_CREATE_INFO view = { + VkDepthStencilViewCreateInfo view = { .sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO, .pNext = NULL, .image = VK_NULL_HANDLE, @@ -421,11 +421,11 @@ static void demo_prepare_depth(struct demo *demo) .flags = 0, }; - VK_MEMORY_REQUIREMENTS *mem_reqs; - size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS); - VK_IMAGE_MEMORY_REQUIREMENTS img_reqs; - size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS); - VK_RESULT err; + VkMemoryRequirements *mem_reqs; + size_t mem_reqs_size = sizeof(VkMemoryRequirements); + VkImageMemoryRequirements img_reqs; + size_t img_reqs_size = sizeof(VkImageMemoryRequirements); + VkResult err; uint32_t num_allocations = 0; size_t num_alloc_size = sizeof(num_allocations); @@ -438,17 +438,17 @@ static void demo_prepare_depth(struct demo *demo) err = vkGetObjectInfo(demo->depth.image, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); - mem_reqs = malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); - demo->depth.mem = malloc(num_allocations * sizeof(VK_GPU_MEMORY)); + mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); + demo->depth.mem = malloc(num_allocations * sizeof(VkGpuMemory)); demo->depth.num_mem = num_allocations; err = vkGetObjectInfo(demo->depth.image, VK_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); - assert(!err && mem_reqs_size == num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); + assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); err = vkGetObjectInfo(demo->depth.image, VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, &img_reqs_size, &img_reqs); - assert(!err && img_reqs_size == sizeof(VK_IMAGE_MEMORY_REQUIREMENTS)); + assert(!err && img_reqs_size == sizeof(VkImageMemoryRequirements)); img_alloc.usage = img_reqs.usage; img_alloc.formatClass = img_reqs.formatClass; img_alloc.samples = img_reqs.samples; @@ -482,18 +482,18 @@ static void demo_prepare_depth(struct demo *demo) static void demo_prepare_texture_image(struct demo *demo, const uint32_t *tex_colors, struct texture_object *tex_obj, - VK_IMAGE_TILING tiling, - VK_FLAGS mem_props) + VkImageTiling tiling, + VkFlags mem_props) { - const VK_FORMAT tex_format = VK_FMT_B8G8R8A8_UNORM; + const VkFormat tex_format = VK_FMT_B8G8R8A8_UNORM; const int32_t tex_width = 2; const int32_t tex_height = 2; - VK_RESULT err; + VkResult err; tex_obj->tex_width = tex_width; tex_obj->tex_height = tex_height; - const VK_IMAGE_CREATE_INFO image_create_info = { + const VkImageCreateInfo image_create_info = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = NULL, .imageType = VK_IMAGE_2D, @@ -519,10 +519,10 @@ static void demo_prepare_texture_image(struct demo *demo, .memPriority = VK_MEMORY_PRIORITY_NORMAL, }; - VK_MEMORY_REQUIREMENTS *mem_reqs; - size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS); - VK_IMAGE_MEMORY_REQUIREMENTS img_reqs; - size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS); + VkMemoryRequirements *mem_reqs; + size_t mem_reqs_size = sizeof(VkMemoryRequirements); + VkImageMemoryRequirements img_reqs; + size_t img_reqs_size = sizeof(VkImageMemoryRequirements); uint32_t num_allocations = 0; size_t num_alloc_size = sizeof(num_allocations); @@ -534,16 +534,16 @@ static void demo_prepare_texture_image(struct demo *demo, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); - mem_reqs = malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); - tex_obj->mem = malloc(num_allocations * sizeof(VK_GPU_MEMORY)); + mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); + tex_obj->mem = malloc(num_allocations * sizeof(VkGpuMemory)); err = vkGetObjectInfo(tex_obj->image, VK_INFO_TYPE_MEMORY_REQUIREMENTS, &mem_reqs_size, mem_reqs); - assert(!err && mem_reqs_size == num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); + assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements)); err = vkGetObjectInfo(tex_obj->image, VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, &img_reqs_size, &img_reqs); - assert(!err && img_reqs_size == sizeof(VK_IMAGE_MEMORY_REQUIREMENTS)); + assert(!err && img_reqs_size == sizeof(VkImageMemoryRequirements)); img_alloc.usage = img_reqs.usage; img_alloc.formatClass = img_reqs.formatClass; img_alloc.samples = img_reqs.samples; @@ -567,13 +567,13 @@ static void demo_prepare_texture_image(struct demo *demo, tex_obj->num_mem = num_allocations; if (mem_props & VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT) { - const VK_IMAGE_SUBRESOURCE subres = { + const VkImageSubresource subres = { .aspect = VK_IMAGE_ASPECT_COLOR, .mipLevel = 0, .arraySlice = 0, }; - VK_SUBRESOURCE_LAYOUT layout; - size_t layout_size = sizeof(VK_SUBRESOURCE_LAYOUT); + VkSubresourceLayout layout; + size_t layout_size = sizeof(VkSubresourceLayout); void *data; int32_t x, y; @@ -618,13 +618,13 @@ static void demo_destroy_texture_image(struct texture_object *tex_obj) static void demo_prepare_textures(struct demo *demo) { - const VK_FORMAT tex_format = VK_FMT_B8G8R8A8_UNORM; - VK_FORMAT_PROPERTIES props; + const VkFormat tex_format = VK_FMT_B8G8R8A8_UNORM; + VkFormatProperties props; size_t size = sizeof(props); const uint32_t tex_colors[DEMO_TEXTURE_COUNT][2] = { { 0xffff0000, 0xff00ff00 }, }; - VK_RESULT err; + VkResult err; uint32_t i; err = vkGetFormatInfo(demo->device, tex_format, @@ -656,7 +656,7 @@ static void demo_prepare_textures(struct demo *demo) demo->textures[i].imageLayout, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL); - VK_IMAGE_COPY copy_region = { + VkImageCopy copy_region = { .srcSubresource = { VK_IMAGE_ASPECT_COLOR, 0, 0 }, .srcOffset = { 0, 0, 0 }, .destSubresource = { VK_IMAGE_ASPECT_COLOR, 0, 0 }, @@ -684,7 +684,7 @@ static void demo_prepare_textures(struct demo *demo) assert(!"No support for B8G8R8A8_UNORM as texture image format"); } - const VK_SAMPLER_CREATE_INFO sampler = { + const VkSamplerCreateInfo sampler = { .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, .pNext = NULL, .magFilter = VK_TEX_FILTER_NEAREST, @@ -700,7 +700,7 @@ static void demo_prepare_textures(struct demo *demo) .maxLod = 0.0f, .borderColorType = VK_BORDER_COLOR_OPAQUE_WHITE, }; - VK_IMAGE_VIEW_CREATE_INFO view = { + VkImageViewCreateInfo view = { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .pNext = NULL, .image = VK_NULL_HANDLE, @@ -754,13 +754,13 @@ static void demo_prepare_vertices(struct demo *demo) .memType = VK_MEMORY_TYPE_BUFFER, .memPriority = VK_MEMORY_PRIORITY_NORMAL, }; - VK_MEMORY_REQUIREMENTS *mem_reqs; - size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS); - VK_BUFFER_MEMORY_REQUIREMENTS buf_reqs; - size_t buf_reqs_size = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS); + VkMemoryRequirements *mem_reqs; + size_t mem_reqs_size = sizeof(VkMemoryRequirements); + VkBufferMemoryRequirements buf_reqs; + size_t buf_reqs_size = sizeof(VkBufferMemoryRequirements); uint32_t num_allocations = 0; size_t num_alloc_size = sizeof(num_allocations); - VK_RESULT err; + VkResult err; void *data; memset(&demo->vertices, 0, sizeof(demo->vertices)); @@ -772,8 +772,8 @@ static void demo_prepare_vertices(struct demo *demo) VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, &num_alloc_size, &num_allocations); assert(!err && num_alloc_size == sizeof(num_allocations)); - mem_reqs = malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS)); - demo->vertices.mem = malloc(num_allocations * sizeof(VK_GPU_MEMORY)); + mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements)); + demo->vertices.mem = malloc(num_allocations * sizeof(VkGpuMemory)); demo->vertices.num_mem = num_allocations; err = vkGetObjectInfo(demo->vertices.buf, VK_INFO_TYPE_MEMORY_REQUIREMENTS, @@ -782,7 +782,7 @@ static void demo_prepare_vertices(struct demo *demo) err = vkGetObjectInfo(demo->vertices.buf, VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS, &buf_reqs_size, &buf_reqs); - assert(!err && buf_reqs_size == sizeof(VK_BUFFER_MEMORY_REQUIREMENTS)); + assert(!err && buf_reqs_size == sizeof(VkBufferMemoryRequirements)); buf_alloc.usage = buf_reqs.usage; for (uint32_t i = 0; i < num_allocations; i ++) { mem_alloc.allocationSize = mem_reqs[i].size; @@ -828,19 +828,19 @@ static void demo_prepare_vertices(struct demo *demo) static void demo_prepare_descriptor_layout(struct demo *demo) { - const VK_DESCRIPTOR_SET_LAYOUT_BINDING layout_binding = { + const VkDescriptorSetLayoutBinding layout_binding = { .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE, .count = DEMO_TEXTURE_COUNT, .stageFlags = VK_SHADER_STAGE_FLAGS_FRAGMENT_BIT, .pImmutableSamplers = NULL, }; - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO descriptor_layout = { + const VkDescriptorSetLayoutCreateInfo descriptor_layout = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, .pNext = NULL, .count = 1, .pBinding = &layout_binding, }; - VK_RESULT err; + VkResult err; err = vkCreateDescriptorSetLayout(demo->device, &descriptor_layout, &demo->desc_layout); @@ -851,14 +851,14 @@ static void demo_prepare_descriptor_layout(struct demo *demo) assert(!err); } -static VK_SHADER demo_prepare_shader(struct demo *demo, - VK_PIPELINE_SHADER_STAGE stage, +static VkShader demo_prepare_shader(struct demo *demo, + VkPipelineShaderStage stage, const void *code, size_t size) { - VK_SHADER_CREATE_INFO createInfo; - VK_SHADER shader; - VK_RESULT err; + VkShaderCreateInfo createInfo; + VkShader shader; + VkResult err; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO; createInfo.pNext = NULL; @@ -869,7 +869,7 @@ static VK_SHADER demo_prepare_shader(struct demo *demo, createInfo.pCode = malloc(createInfo.codeSize); createInfo.flags = 0; - /* try version 0 first: VK_PIPELINE_SHADER_STAGE followed by GLSL */ + /* try version 0 first: VkPipelineShaderStage followed by GLSL */ ((uint32_t *) createInfo.pCode)[0] = ICD_SPV_MAGIC; ((uint32_t *) createInfo.pCode)[1] = 0; ((uint32_t *) createInfo.pCode)[2] = stage; @@ -884,7 +884,7 @@ static VK_SHADER demo_prepare_shader(struct demo *demo, return shader; } -static VK_SHADER demo_prepare_vs(struct demo *demo) +static VkShader demo_prepare_vs(struct demo *demo) { static const char *vertShaderText = "#version 140\n" @@ -903,7 +903,7 @@ static VK_SHADER demo_prepare_vs(struct demo *demo) strlen(vertShaderText)); } -static VK_SHADER demo_prepare_fs(struct demo *demo) +static VkShader demo_prepare_fs(struct demo *demo) { static const char *fragShaderText = "#version 140\n" @@ -922,17 +922,17 @@ static VK_SHADER demo_prepare_fs(struct demo *demo) static void demo_prepare_pipeline(struct demo *demo) { - VK_GRAPHICS_PIPELINE_CREATE_INFO pipeline; - VK_PIPELINE_VERTEX_INPUT_CREATE_INFO vi; - VK_PIPELINE_IA_STATE_CREATE_INFO ia; - VK_PIPELINE_RS_STATE_CREATE_INFO rs; - VK_PIPELINE_CB_STATE_CREATE_INFO cb; - VK_PIPELINE_DS_STATE_CREATE_INFO ds; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO vs; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO fs; - VK_PIPELINE_VP_STATE_CREATE_INFO vp; - VK_PIPELINE_MS_STATE_CREATE_INFO ms; - VK_RESULT err; + VkGraphicsPipelineCreateInfo pipeline; + VkPipelineVertexInputCreateInfo vi; + VkPipelineIaStateCreateInfo ia; + VkPipelineRsStateCreateInfo rs; + VkPipelineCbStateCreateInfo cb; + VkPipelineDsStateCreateInfo ds; + VkPipelineShaderStageCreateInfo vs; + VkPipelineShaderStageCreateInfo fs; + VkPipelineVpStateCreateInfo vp; + VkPipelineMsStateCreateInfo ms; + VkResult err; memset(&pipeline, 0, sizeof(pipeline)); pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; @@ -952,7 +952,7 @@ static void demo_prepare_pipeline(struct demo *demo) memset(&cb, 0, sizeof(cb)); cb.sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO; - VK_PIPELINE_CB_ATTACHMENT_STATE att_state[1]; + VkPipelineCbAttachmentState att_state[1]; memset(att_state, 0, sizeof(att_state)); att_state[0].format = demo->format; att_state[0].channelWriteMask = 0xf; @@ -1015,23 +1015,23 @@ static void demo_prepare_pipeline(struct demo *demo) static void demo_prepare_dynamic_states(struct demo *demo) { - VK_DYNAMIC_VP_STATE_CREATE_INFO viewport_create; - VK_DYNAMIC_RS_STATE_CREATE_INFO raster; - VK_DYNAMIC_CB_STATE_CREATE_INFO color_blend; - VK_DYNAMIC_DS_STATE_CREATE_INFO depth_stencil; - VK_RESULT err; + VkDynamicVpStateCreateInfo viewport_create; + VkDynamicRsStateCreateInfo raster; + VkDynamicCbStateCreateInfo color_blend; + VkDynamicDsStateCreateInfo depth_stencil; + VkResult err; memset(&viewport_create, 0, sizeof(viewport_create)); viewport_create.sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO; viewport_create.viewportAndScissorCount = 1; - VK_VIEWPORT viewport; + VkViewport viewport; memset(&viewport, 0, sizeof(viewport)); viewport.height = (float) demo->height; viewport.width = (float) demo->width; viewport.minDepth = (float) 0.0f; viewport.maxDepth = (float) 1.0f; viewport_create.pViewports = &viewport; - VK_RECT scissor; + VkRect scissor; memset(&scissor, 0, sizeof(scissor)); scissor.extent.width = demo->width; scissor.extent.height = demo->height; @@ -1077,17 +1077,17 @@ static void demo_prepare_dynamic_states(struct demo *demo) static void demo_prepare_descriptor_pool(struct demo *demo) { - const VK_DESCRIPTOR_TYPE_COUNT type_count = { + const VkDescriptorTypeCount type_count = { .type = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE, .count = DEMO_TEXTURE_COUNT, }; - const VK_DESCRIPTOR_POOL_CREATE_INFO descriptor_pool = { + const VkDescriptorPoolCreateInfo descriptor_pool = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, .pNext = NULL, .count = 1, .pTypeCount = &type_count, }; - VK_RESULT err; + VkResult err; err = vkCreateDescriptorPool(demo->device, VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, @@ -1097,11 +1097,11 @@ static void demo_prepare_descriptor_pool(struct demo *demo) static void demo_prepare_descriptor_set(struct demo *demo) { - VK_IMAGE_VIEW_ATTACH_INFO view_info[DEMO_TEXTURE_COUNT]; - VK_SAMPLER_IMAGE_VIEW_INFO combined_info[DEMO_TEXTURE_COUNT]; - VK_UPDATE_SAMPLER_TEXTURES update; + VkImageViewAttachInfo view_info[DEMO_TEXTURE_COUNT]; + VkSamplerImageViewInfo combined_info[DEMO_TEXTURE_COUNT]; + VkUpdateSamplerTextures update; const void *update_array[1] = { &update }; - VK_RESULT err; + VkResult err; uint32_t count; uint32_t i; @@ -1137,13 +1137,13 @@ static void demo_prepare_descriptor_set(struct demo *demo) static void demo_prepare(struct demo *demo) { - const VK_CMD_BUFFER_CREATE_INFO cmd = { + const VkCmdBufferCreateInfo cmd = { .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, .pNext = NULL, .queueNodeIndex = demo->graphics_queue_node_index, .flags = 0, }; - VK_RESULT err; + VkResult err; demo_prepare_buffers(demo); demo_prepare_depth(demo); @@ -1243,7 +1243,7 @@ static void demo_create_window(struct demo *demo) static void demo_init_vk(struct demo *demo) { - const VK_APPLICATION_INFO app = { + const VkApplicationInfo app = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pNext = NULL, .pAppName = "tri", @@ -1282,7 +1282,7 @@ static void demo_init_vk(struct demo *demo) .maxValidationLevel = VK_VALIDATION_LEVEL_END_RANGE, .flags = VK_DEVICE_CREATE_VALIDATION_BIT, }; - VK_RESULT err; + VkResult err; uint32_t gpu_count; uint32_t i; size_t data_size; @@ -1316,7 +1316,7 @@ static void demo_init_vk(struct demo *demo) &data_size, NULL); assert(!err); - demo->gpu_props = (VK_PHYSICAL_GPU_PROPERTIES *) malloc(data_size); + demo->gpu_props = (VkPhysicalGpuProperties *) malloc(data_size); err = vkGetGpuInfo(demo->gpu, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &data_size, demo->gpu_props); assert(!err); @@ -1325,11 +1325,11 @@ static void demo_init_vk(struct demo *demo) &data_size, NULL); assert(!err); - demo->queue_props = (VK_PHYSICAL_GPU_QUEUE_PROPERTIES *) malloc(data_size); + demo->queue_props = (VkPhysicalGpuQueueProperties *) malloc(data_size); err = vkGetGpuInfo(demo->gpu, VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, &data_size, demo->queue_props); assert(!err); - queue_count = (uint32_t) (data_size / sizeof(VK_PHYSICAL_GPU_QUEUE_PROPERTIES)); + queue_count = (uint32_t) (data_size / sizeof(VkPhysicalGpuQueueProperties)); assert(queue_count >= 1); for (i = 0; i < queue_count; i++) { diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c index 3bc416f6..47edf534 100644 --- a/demos/vulkaninfo.c +++ b/demos/vulkaninfo.c @@ -45,24 +45,24 @@ struct app_gpu; struct app_dev { struct app_gpu *gpu; /* point back to the GPU */ - VK_DEVICE obj; + VkDevice obj; - VK_FORMAT_PROPERTIES format_props[VK_NUM_FMT]; + VkFormatProperties format_props[VK_NUM_FMT]; }; struct app_gpu { uint32_t id; - VK_PHYSICAL_GPU obj; + VkPhysicalGpu obj; - VK_PHYSICAL_GPU_PROPERTIES props; - VK_PHYSICAL_GPU_PERFORMANCE perf; + VkPhysicalGpuProperties props; + VkPhysicalGpuPerformance perf; uint32_t queue_count; - VK_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props; + VkPhysicalGpuQueueProperties *queue_props; VkDeviceQueueCreateInfo *queue_reqs; - VK_PHYSICAL_GPU_MEMORY_PROPERTIES memory_props; + VkPhysicalGpuMemoryProperties memory_props; uint32_t extension_count; char **extensions; @@ -70,7 +70,7 @@ struct app_gpu { struct app_dev dev; }; -static const char *vk_result_string(VK_RESULT err) +static const char *vk_result_string(VkResult err) { switch (err) { #define STR(r) case r: return #r @@ -119,7 +119,7 @@ static const char *vk_result_string(VK_RESULT err) } } -static const char *vk_gpu_type_string(VK_PHYSICAL_GPU_TYPE type) +static const char *vk_gpu_type_string(VkPhysicalGpuType type) { switch (type) { #define STR(r) case VK_GPU_TYPE_ ##r: return #r @@ -132,7 +132,7 @@ static const char *vk_gpu_type_string(VK_PHYSICAL_GPU_TYPE type) } } -static const char *vk_format_string(VK_FORMAT fmt) +static const char *vk_format_string(VkFormat fmt) { switch (fmt) { #define STR(r) case VK_FMT_ ##r: return #r @@ -310,11 +310,11 @@ static const char *vk_format_string(VK_FORMAT fmt) static void app_dev_init_formats(struct app_dev *dev) { - VK_FORMAT f; + VkFormat f; for (f = 0; f < VK_NUM_FMT; f++) { - const VK_FORMAT fmt = f; - VK_RESULT err; + const VkFormat fmt = f; + VkResult err; size_t size = sizeof(dev->format_props[f]); err = vkGetFormatInfo(dev->obj, fmt, @@ -342,7 +342,7 @@ static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu) .maxValidationLevel = VK_VALIDATION_LEVEL_END_RANGE, .flags = VK_DEVICE_CREATE_VALIDATION_BIT, }; - VK_RESULT err; + VkResult err; /* request all queues */ info.queueRecordCount = gpu->queue_count; @@ -365,7 +365,7 @@ static void app_dev_destroy(struct app_dev *dev) static void app_gpu_init_extensions(struct app_gpu *gpu) { - VK_RESULT err; + VkResult err; uint32_t i; static char *known_extensions[] = { @@ -391,10 +391,10 @@ static void app_gpu_init_extensions(struct app_gpu *gpu) } } -static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VK_PHYSICAL_GPU obj) +static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VkPhysicalGpu obj) { size_t size; - VK_RESULT err; + VkResult err; uint32_t i; memset(gpu, 0, sizeof(*gpu)); @@ -464,12 +464,12 @@ static void app_gpu_destroy(struct app_gpu *gpu) free(gpu->queue_props); } -static void app_dev_dump_format_props(const struct app_dev *dev, VK_FORMAT fmt) +static void app_dev_dump_format_props(const struct app_dev *dev, VkFormat fmt) { - const VK_FORMAT_PROPERTIES *props = &dev->format_props[fmt]; + const VkFormatProperties *props = &dev->format_props[fmt]; struct { const char *name; - VK_FLAGS flags; + VkFlags flags; } tilings[2]; uint32_t i; @@ -507,7 +507,7 @@ static void app_dev_dump_format_props(const struct app_dev *dev, VK_FORMAT fmt) static void app_dev_dump(const struct app_dev *dev) { - VK_FORMAT fmt; + VkFormat fmt; for (fmt = 0; fmt < VK_NUM_FMT; fmt++) { app_dev_dump_format_props(dev, fmt); @@ -515,9 +515,9 @@ app_dev_dump(const struct app_dev *dev) } static void app_gpu_dump_multi_compat(const struct app_gpu *gpu, const struct app_gpu *other, - const VK_GPU_COMPATIBILITY_INFO *info) + const VkGpuCompatibilityInfo *info) { - printf("VK_GPU_COMPATIBILITY_INFO[GPU%d]\n", other->id); + printf("VkGpuCompatibilityInfo[GPU%d]\n", other->id); #define TEST(info, b) printf(#b " = %u\n", (bool) (info->compatibilityFlags & VK_GPU_COMPAT_ ##b## _BIT)) TEST(info, ASIC_FEATURES); @@ -532,12 +532,12 @@ static void app_gpu_dump_multi_compat(const struct app_gpu *gpu, const struct ap static void app_gpu_multi_compat(struct app_gpu *gpus, uint32_t gpu_count) { - VK_RESULT err; + VkResult err; uint32_t i, j; for (i = 0; i < gpu_count; i++) { for (j = 0; j < gpu_count; j++) { - VK_GPU_COMPATIBILITY_INFO info; + VkGpuCompatibilityInfo info; if (i == j) continue; @@ -554,9 +554,9 @@ static void app_gpu_multi_compat(struct app_gpu *gpus, uint32_t gpu_count) static void app_gpu_dump_props(const struct app_gpu *gpu) { - const VK_PHYSICAL_GPU_PROPERTIES *props = &gpu->props; + const VkPhysicalGpuProperties *props = &gpu->props; - printf("VK_PHYSICAL_GPU_PROPERTIES\n"); + printf("VkPhysicalGpuProperties\n"); printf("\tapiVersion = %u\n", props->apiVersion); printf("\tdriverVersion = %u\n", props->driverVersion); printf("\tvendorId = 0x%04x\n", props->vendorId); @@ -572,9 +572,9 @@ static void app_gpu_dump_props(const struct app_gpu *gpu) static void app_gpu_dump_perf(const struct app_gpu *gpu) { - const VK_PHYSICAL_GPU_PERFORMANCE *perf = &gpu->perf; + const VkPhysicalGpuPerformance *perf = &gpu->perf; - printf("VK_PHYSICAL_GPU_PERFORMANCE\n"); + printf("VkPhysicalGpuPerformance\n"); printf("\tmaxGpuClock = %f\n", perf->maxGpuClock); printf("\taluPerClock = %f\n", perf->aluPerClock); printf("\ttexPerClock = %f\n", perf->texPerClock); @@ -598,9 +598,9 @@ static void app_gpu_dump_extensions(const struct app_gpu *gpu) static void app_gpu_dump_queue_props(const struct app_gpu *gpu, uint32_t id) { - const VK_PHYSICAL_GPU_QUEUE_PROPERTIES *props = &gpu->queue_props[id]; + const VkPhysicalGpuQueueProperties *props = &gpu->queue_props[id]; - printf("VK_PHYSICAL_GPU_QUEUE_PROPERTIES[%d]\n", id); + printf("VkPhysicalGpuQueueProperties[%d]\n", id); printf("\tqueueFlags = %c%c%c%c\n", (props->queueFlags & VK_QUEUE_GRAPHICS_BIT) ? 'G' : '.', (props->queueFlags & VK_QUEUE_COMPUTE_BIT) ? 'C' : '.', @@ -614,9 +614,9 @@ static void app_gpu_dump_queue_props(const struct app_gpu *gpu, uint32_t id) static void app_gpu_dump_memory_props(const struct app_gpu *gpu) { - const VK_PHYSICAL_GPU_MEMORY_PROPERTIES *props = &gpu->memory_props; + const VkPhysicalGpuMemoryProperties *props = &gpu->memory_props; - printf("VK_PHYSICAL_GPU_MEMORY_PROPERTIES\n"); + printf("VkPhysicalGpuMemoryProperties\n"); printf("\tsupportsMigration = %u\n", props->supportsMigration); printf("\tsupportsPinning = %u\n", props->supportsPinning); } @@ -643,7 +643,7 @@ static void app_gpu_dump(const struct app_gpu *gpu) int main(int argc, char **argv) { - static const VK_APPLICATION_INFO app_info = { + static const VkApplicationInfo app_info = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pNext = NULL, .pAppName = "vkinfo", @@ -661,10 +661,10 @@ int main(int argc, char **argv) .ppEnabledExtensionNames = NULL, }; struct app_gpu gpus[MAX_GPUS]; - VK_PHYSICAL_GPU objs[MAX_GPUS]; - VK_INSTANCE inst; + VkPhysicalGpu objs[MAX_GPUS]; + VkInstance inst; uint32_t gpu_count, i; - VK_RESULT err; + VkResult err; err = vkCreateInstance(&inst_info, &inst); if (err == VK_ERROR_INCOMPATIBLE_DRIVER) { diff --git a/docs/vk_ds.dot b/docs/vk_ds.dot index 2615beeb..514614cd 100644 --- a/docs/vk_ds.dot +++ b/docs/vk_ds.dot @@ -12,27 +12,27 @@ subgraph clusterDSCreate1 { label="vkCreateDescriptorSet()" "_VK_DESCRIPTOR_SET_CREATE_INFO1" [ -label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> ]; } subgraph clusterDSCreate2 { label="vkCreateDescriptorSet()" "_VK_DESCRIPTOR_SET_CREATE_INFO2" [ -label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> ]; } subgraph clusterSamplerCreate { -label="vkCreateSampler - multiple calls return unique VK_SAMPLER handles" +label="vkCreateSampler - multiple calls return unique VkSampler handles" "_VK_SAMPLER_CREATE_INFO_0" [ -label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +label = <
VkSamplerCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VkTexFiltermagFilter
VkTexFilterminFilter
VkTexMipmapModemipMode
VkTexAddressaddressU
VkTexAddressaddressV
VkTexAddressaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VkCompareFunccompareFunc
floatminLod
floatmaxLod
VkBorderColorTypeborderColorType
> ]; "SAMPLER_ELLIPSES" [ label = "..." ]; "_VK_SAMPLER_CREATE_INFO_19" [ -label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +label = <
VkSamplerCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VkTexFiltermagFilter
VkTexFilterminFilter
VkTexMipmapModemipMode
VkTexAddressaddressU
VkTexAddressaddressV
VkTexAddressaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VkCompareFunccompareFunc
floatminLod
floatmaxLod
VkBorderColorTypeborderColorType
> ]; } subgraph clusterSamplerAttach @@ -52,26 +52,26 @@ subgraph clusterMemoryView { label="vkAttachMemoryViewDescriptors - pMemViews array of VK_MEMORY_VIEW_ATTACH_INFO structs" "_VK_MEMORY_VIEW_ATTACH_INFO_3" [ -label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VkGpuMemorymem
VkGpuSizeoffset
VkGpuSizerange
VkGpuSizestride
VkFormatformat
VK_MEMORY_STATEstate
> ]; "MEM_VIEW_ELLIPSES" [ label = "..." ]; "_VK_MEMORY_VIEW_ATTACH_INFO_0" [ -label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VkGpuMemorymem
VkGpuSizeoffset
VkGpuSizerange
VkGpuSizestride
VkFormatformat
VK_MEMORY_STATEstate
> ]; } subgraph clusterImageView { -label="vkAttachImageViewDescriptors - pImageViews array of VK_IMAGE_VIEW_ATTACH_INFO structs" +label="vkAttachImageViewDescriptors - pImageViews array of VkImageViewAttachInfo structs" "_VK_IMAGE_VIEW_ATTACH_INFO_9" [ -label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +label = <
VkImageViewAttachInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VkImageViewview
VK_IMAGE_STATEstate
> ]; "IMG_VIEW_ELLIPSES" [ label = "..." ]; "_VK_IMAGE_VIEW_ATTACH_INFO_0" [ -label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +label = <
VkImageViewAttachInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VkImageViewview
VK_IMAGE_STATEstate
> ]; } "VS_VK_DESCRIPTOR_SET_MAPPING" [ diff --git a/docs/vk_full_pipeline_ds.dot b/docs/vk_full_pipeline_ds.dot index 6132b3a7..894e235c 100644 --- a/docs/vk_full_pipeline_ds.dot +++ b/docs/vk_full_pipeline_ds.dot @@ -8,67 +8,67 @@ shape = "plaintext" ]; edge [ ]; -"_VK_GRAPHICS_PIPELINE_CREATE_INFO" [ -label = <
VK_GRAPHICS_PIPELINE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
VK_FLAGSflags
> +"VkGraphicsPipelineCreateInfo_" [ +label = <
VkGraphicsPipelineCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
VkFlagsflags
> ]; -"_VK_PIPELINE_IA_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_IA_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
VK_PRIMITIVE_TOPOLOGYtopology
bool32_tdisableVertexReuse
VK_PROVOKING_VERTEX_CONVENTIONprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> +"VkPipelineIaStateCreateInfo_" [ +label = <
VkPipelineIaStateCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
VkPrimitiveTopologytopology
bool32_tdisableVertexReuse
VkProvokingVertexConventionprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> ]; -"_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_TESS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> +"VkPipelineTessStateCreateInfo_" [ +label = <
VkPipelineTessStateCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> ]; -"_VK_PIPELINE_RS_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_RS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> +"VkPipelineRsStateCreateInfo_" [ +label = <
VkPipelineRsStateCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> ]; -"_VK_PIPELINE_CB_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_CB_STATE
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
VK_LOGIC_OPlogicOp
VK_PIPELINE_CB_ATTACHMENT_STATEattachment
> +"VkPipelineCbStateCreateInfo_" [ +label = <
VK_PIPELINE_CB_STATE
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
VkLogicOplogicOp
VkPipelineCbAttachmentStateattachment
> ]; "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_DB_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
VK_FORMATformat
> +label = <
VK_PIPELINE_DB_STATE_CREATE_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
VkFormatformat
> ]; "VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
VkPipelineShadershader
> ]; "VS_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=VS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=VS
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "TC_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TC
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=TC
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "TE_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TE
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=TE
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "GS_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=GS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=GS
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "FS_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=FS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=FS
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; -"_VK_GRAPHICS_PIPELINE_CREATE_INFO":f2 -> "_VK_PIPELINE_IA_STATE_CREATE_INFO" [ +"VkGraphicsPipelineCreateInfo_":f2 -> "VkPipelineIaStateCreateInfo_" [ id = 100 ]; -"_VK_PIPELINE_IA_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ +"VkPipelineIaStateCreateInfo_":f2 -> "VkPipelineTessStateCreateInfo_" [ id = 101 ]; -"_VK_PIPELINE_TESS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_RS_STATE_CREATE_INFO" [ +"VkPipelineTessStateCreateInfo_":f2 -> "VkPipelineRsStateCreateInfo_" [ id = 102 ]; -"_VK_PIPELINE_RS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_CB_STATE_CREATE_INFO" [ +"VkPipelineRsStateCreateInfo_":f2 -> "VkPipelineCbStateCreateInfo_" [ id = 103 ]; -"_VK_PIPELINE_CB_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ +"VkPipelineCbStateCreateInfo_":f2 -> "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ id = 104 ]; "_VK_PIPELINE_DB_STATE_CREATE_INFO":f2 -> "VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ @@ -105,27 +105,27 @@ subgraph clusterDSCreate1 { label="vkCreateDescriptorSet()" "_VK_DESCRIPTOR_SET_CREATE_INFO1" [ -label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=14
> ]; } subgraph clusterDSCreate2 { label="vkCreateDescriptorSet()" "_VK_DESCRIPTOR_SET_CREATE_INFO2" [ -label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> +label = <
VK_DESCRIPTOR_SET_CREATE_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const void*pNext=NULL
uint32_tslots=20
> ]; } subgraph clusterSamplerCreate { -label="vkCreateSampler - multiple calls return unique VK_SAMPLER handles" +label="vkCreateSampler - multiple calls return unique VkSampler handles" "_VK_SAMPLER_CREATE_INFO_0" [ -label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +label = <
VkSamplerCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VkTexFiltermagFilter
VkTexFilterminFilter
VkTexMipmapModemipMode
VkTexAddressaddressU
VkTexAddressaddressV
VkTexAddressaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VkCompareFunccompareFunc
floatminLod
floatmaxLod
VkBorderColorTypeborderColorType
> ]; "SAMPLER_ELLIPSES" [ label = "..." ]; "_VK_SAMPLER_CREATE_INFO_19" [ -label = <
VK_SAMPLER_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VK_TEX_FILTERmagFilter
VK_TEX_FILTERminFilter
VK_TEX_MIPMAP_MODEmipMode
VK_TEX_ADDRESSaddressU
VK_TEX_ADDRESSaddressV
VK_TEX_ADDRESSaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VK_COMPARE_FUNCcompareFunc
floatminLod
floatmaxLod
VK_BORDER_COLOR_TYPEborderColorType
> +label = <
VkSamplerCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void*pNext=NULL
VkTexFiltermagFilter
VkTexFilterminFilter
VkTexMipmapModemipMode
VkTexAddressaddressU
VkTexAddressaddressV
VkTexAddressaddressW
floatmipLodBias
uint32_tmaxAnisotropy
VkCompareFunccompareFunc
floatminLod
floatmaxLod
VkBorderColorTypeborderColorType
> ]; } subgraph clusterSamplerAttach @@ -145,26 +145,26 @@ subgraph clusterMemoryView { label="vkAttachMemoryViewDescriptors - pMemViews array of VK_MEMORY_VIEW_ATTACH_INFO structs" "_VK_MEMORY_VIEW_ATTACH_INFO_3" [ -label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VkGpuMemorymem
VkGpuSizeoffset
VkGpuSizerange
VkGpuSizestride
VkFormatformat
VK_MEMORY_STATEstate
> ]; "MEM_VIEW_ELLIPSES" [ label = "..." ]; "_VK_MEMORY_VIEW_ATTACH_INFO_0" [ -label = <
VK_MEMORY_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VK_GPU_MEMORYmem
VK_GPU_SIZEoffset
VK_GPU_SIZErange
VK_GPU_SIZEstride
VK_FORMATformat
VK_MEMORY_STATEstate
> +label = <
VK_MEMORY_VIEW_ATTACH_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
void*pNext=NULL
VkGpuMemorymem
VkGpuSizeoffset
VkGpuSizerange
VkGpuSizestride
VkFormatformat
VK_MEMORY_STATEstate
> ]; } subgraph clusterImageView { -label="vkAttachImageViewDescriptors - pImageViews array of VK_IMAGE_VIEW_ATTACH_INFO structs" +label="vkAttachImageViewDescriptors - pImageViews array of VkImageViewAttachInfo structs" "_VK_IMAGE_VIEW_ATTACH_INFO_9" [ -label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +label = <
VkImageViewAttachInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VkImageViewview
VK_IMAGE_STATEstate
> ]; "IMG_VIEW_ELLIPSES" [ label = "..." ]; "_VK_IMAGE_VIEW_ATTACH_INFO_0" [ -label = <
VK_IMAGE_VIEW_ATTACH_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VK_IMAGE_VIEWview
VK_IMAGE_STATEstate
> +label = <
VkImageViewAttachInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
void*pNext=NULL
VkImageViewview
VK_IMAGE_STATEstate
> ]; } "VS_VK_DESCRIPTOR_SET_MAPPING" [ diff --git a/docs/vk_graphics_pipeline.dot b/docs/vk_graphics_pipeline.dot index b6304552..6aea1c4e 100644 --- a/docs/vk_graphics_pipeline.dot +++ b/docs/vk_graphics_pipeline.dot @@ -8,67 +8,67 @@ shape = "plaintext" ]; edge [ ]; -"_VK_GRAPHICS_PIPELINE_CREATE_INFO" [ -label = <
VK_GRAPHICS_PIPELINE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
VK_FLAGSflags
> +"VkGraphicsPipelineCreateInfo_" [ +label = <
VkGraphicsPipelineCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void*pNext
VkFlagsflags
> ]; -"_VK_PIPELINE_IA_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_IA_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
VK_PRIMITIVE_TOPOLOGYtopology
bool32_tdisableVertexReuse
VK_PROVOKING_VERTEX_CONVENTIONprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> +"VkPipelineIaStateCreateInfo_" [ +label = <
VkPipelineIaStateCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const void*pNext
VkPrimitiveTopologytopology
bool32_tdisableVertexReuse
VkProvokingVertexConventionprovokingVertex
bool32_tprimitiveRestartEnable
uint32_tprimitiveRestartIndex
> ]; -"_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_TESS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> +"VkPipelineTessStateCreateInfo_" [ +label = <
VkPipelineTessStateCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
const void*pNext
uint32_tpatchControlPoints
floatoptimalTessFactor
floatfixedTessFactor
> ]; -"_VK_PIPELINE_RS_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_RS_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> +"VkPipelineRsStateCreateInfo_" [ +label = <
VkPipelineRsStateCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const void*pNext
bool32_tdepthClipEnable
bool32_trasterizerDiscardEnable
floatpointSize
> ]; -"_VK_PIPELINE_CB_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_CB_STATE
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
VK_LOGIC_OPlogicOp
VK_PIPELINE_CB_ATTACHMENT_STATEattachment
> +"VkPipelineCbStateCreateInfo_" [ +label = <
VK_PIPELINE_CB_STATE
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const void*pNext
bool32_talphaToCoverageEnable
bool32_tdualSourceBlendEnable
VkLogicOplogicOp
VkPipelineCbAttachmentStateattachment
> ]; "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ -label = <
VK_PIPELINE_DB_STATE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
VK_FORMATformat
> +label = <
VK_PIPELINE_DB_STATE_CREATE_INFO
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
const void*pNext
VkFormatformat
> ]; "VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "TC_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "TE_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "GS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext
VkPipelineShadershader
> ]; "FS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ -label = <
VK_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_STRUCTURE_TYPEsType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
VK_PIPELINE_SHADERshader
> +label = <
VkPipelineShaderStageCreateInfo
VkStructureTypesType=
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void*pNext=NULL
VkPipelineShadershader
> ]; "VS_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=VS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=VS
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "TC_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TC
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=TC
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "TE_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=TE
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=TE
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "GS_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=GS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=GS
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; "FS_VK_PIPELINE_SHADER" [ -label = <
VK_PIPELINE_SHADER
VK_PIPELINE_SHADER_STAGEstage=FS
VK_SHADERshader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VK_LINK_CONST_BUFFER*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> +label = <
VkPipelineShader
VkPipelineShaderStagestage=FS
VkShadershader
VK_DESCRIPTOR_SET_MAPPINGdescriptorSetMapping[2]
uint32_tlinkConstBufferCount
const VkLinkConstBuffer*pLinkConstBufferInfo
VK_DYNAMIC_MEMORY_VIEW_SLOT_INFOdynamicMemoryViewMapping
> ]; -"_VK_GRAPHICS_PIPELINE_CREATE_INFO":f2 -> "_VK_PIPELINE_IA_STATE_CREATE_INFO" [ +"VkGraphicsPipelineCreateInfo_":f2 -> "VkPipelineIaStateCreateInfo_" [ id = 0 ]; -"_VK_PIPELINE_IA_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_TESS_STATE_CREATE_INFO" [ +"VkPipelineIaStateCreateInfo_":f2 -> "VkPipelineTessStateCreateInfo_" [ id = 1 ]; -"_VK_PIPELINE_TESS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_RS_STATE_CREATE_INFO" [ +"VkPipelineTessStateCreateInfo_":f2 -> "VkPipelineRsStateCreateInfo_" [ id = 2 ]; -"_VK_PIPELINE_RS_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_CB_STATE_CREATE_INFO" [ +"VkPipelineRsStateCreateInfo_":f2 -> "VkPipelineCbStateCreateInfo_" [ id = 3 ]; -"_VK_PIPELINE_CB_STATE_CREATE_INFO":f2 -> "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ +"VkPipelineCbStateCreateInfo_":f2 -> "_VK_PIPELINE_DB_STATE_CREATE_INFO" [ id = 4 ]; "_VK_PIPELINE_DB_STATE_CREATE_INFO":f2 -> "VS_VK_PIPELINE_SHADER_STAGE_CREATE_INFO" [ diff --git a/icd/README.md b/icd/README.md index bec64cda..871d1c68 100644 --- a/icd/README.md +++ b/icd/README.md @@ -8,7 +8,7 @@ This sample driver implementation provide multiple subcomponents required to bui common/ provides helper and utility functions, as well as all VK entry points except vkInitAndEnumerateGpus. Hardware drivers are required to provide that function, and to embed a "VK_LAYER_DISPATCH_TABLE *" as the first member of -VK_PHYSICAL_GPU and all VK_BASE_OBJECT. +VkPhysicalGpu and all VkBaseObject. Thread safety diff --git a/icd/common/icd-format.c b/icd/common/icd-format.c index dff3638c..c326cbdc 100644 --- a/icd/common/icd-format.c +++ b/icd/common/icd-format.c @@ -205,7 +205,7 @@ static const struct icd_format_info { [VK_FMT_B10G10R10A2_SINT] = { 4, 4 }, }; -bool icd_format_is_ds(VK_FORMAT format) +bool icd_format_is_ds(VkFormat format) { bool is_ds = false; @@ -226,7 +226,7 @@ bool icd_format_is_ds(VK_FORMAT format) return is_ds; } -bool icd_format_is_norm(VK_FORMAT format) +bool icd_format_is_norm(VkFormat format) { bool is_norm = false; @@ -298,7 +298,7 @@ bool icd_format_is_norm(VK_FORMAT format) return is_norm; }; -bool icd_format_is_int(VK_FORMAT format) +bool icd_format_is_int(VkFormat format) { bool is_int = false; @@ -344,7 +344,7 @@ bool icd_format_is_int(VK_FORMAT format) return is_int; } -bool icd_format_is_float(VK_FORMAT format) +bool icd_format_is_float(VkFormat format) { bool is_float = false; @@ -374,7 +374,7 @@ bool icd_format_is_float(VK_FORMAT format) return is_float; } -bool icd_format_is_srgb(VK_FORMAT format) +bool icd_format_is_srgb(VkFormat format) { bool is_srgb = false; @@ -412,7 +412,7 @@ bool icd_format_is_srgb(VK_FORMAT format) return is_srgb; } -bool icd_format_is_compressed(VK_FORMAT format) +bool icd_format_is_compressed(VkFormat format) { switch (format) { case VK_FMT_BC1_RGB_UNORM: @@ -470,12 +470,12 @@ bool icd_format_is_compressed(VK_FORMAT format) } } -size_t icd_format_get_size(VK_FORMAT format) +size_t icd_format_get_size(VkFormat format) { return icd_format_table[format].size; } -VK_IMAGE_FORMAT_CLASS icd_format_get_class(VK_FORMAT format) +VkImageFormatClass icd_format_get_class(VkFormat format) { if (icd_format_is_undef(format)) assert(!"undefined format"); @@ -541,7 +541,7 @@ VK_IMAGE_FORMAT_CLASS icd_format_get_class(VK_FORMAT format) } } -unsigned int icd_format_get_channel_count(VK_FORMAT format) +unsigned int icd_format_get_channel_count(VkFormat format) { return icd_format_table[format].channel_count; } @@ -550,7 +550,7 @@ unsigned int icd_format_get_channel_count(VK_FORMAT format) * Convert a raw RGBA color to a raw value. \p value must have at least * icd_format_get_size(format) bytes. */ -void icd_format_get_raw_value(VK_FORMAT format, +void icd_format_get_raw_value(VkFormat format, const uint32_t color[4], void *value) { diff --git a/icd/common/icd-format.h b/icd/common/icd-format.h index ea227c13..5a7d1f07 100644 --- a/icd/common/icd-format.h +++ b/icd/common/icd-format.h @@ -31,35 +31,35 @@ #include #include "icd.h" -static inline bool icd_format_is_undef(VK_FORMAT format) +static inline bool icd_format_is_undef(VkFormat format) { return (format == VK_FMT_UNDEFINED); } -bool icd_format_is_ds(VK_FORMAT format); +bool icd_format_is_ds(VkFormat format); -static inline bool icd_format_is_color(VK_FORMAT format) +static inline bool icd_format_is_color(VkFormat format) { return !(icd_format_is_undef(format) || icd_format_is_ds(format)); } -bool icd_format_is_norm(VK_FORMAT format); +bool icd_format_is_norm(VkFormat format); -bool icd_format_is_int(VK_FORMAT format); +bool icd_format_is_int(VkFormat format); -bool icd_format_is_float(VK_FORMAT format); +bool icd_format_is_float(VkFormat format); -bool icd_format_is_srgb(VK_FORMAT format); +bool icd_format_is_srgb(VkFormat format); -bool icd_format_is_compressed(VK_FORMAT format); +bool icd_format_is_compressed(VkFormat format); -static inline int icd_format_get_block_width(VK_FORMAT format) +static inline int icd_format_get_block_width(VkFormat format) { /* all compressed formats use 4x4 blocks */ return (icd_format_is_compressed(format)) ? 4 : 1; } -static inline bool icd_blend_mode_is_dual_src(VK_BLEND mode) +static inline bool icd_blend_mode_is_dual_src(VkBlend mode) { return (mode == VK_BLEND_SRC1_COLOR) || (mode == VK_BLEND_SRC1_ALPHA) || @@ -67,7 +67,7 @@ static inline bool icd_blend_mode_is_dual_src(VK_BLEND mode) (mode == VK_BLEND_ONE_MINUS_SRC1_ALPHA); } -static inline bool icd_pipeline_cb_att_needs_dual_source_blending(const VK_PIPELINE_CB_ATTACHMENT_STATE *att) +static inline bool icd_pipeline_cb_att_needs_dual_source_blending(const VkPipelineCbAttachmentState *att) { if (icd_blend_mode_is_dual_src(att->srcBlendColor) || icd_blend_mode_is_dual_src(att->srcBlendAlpha) || @@ -78,13 +78,13 @@ static inline bool icd_pipeline_cb_att_needs_dual_source_blending(const VK_PIPEL return false; } -size_t icd_format_get_size(VK_FORMAT format); +size_t icd_format_get_size(VkFormat format); -VK_IMAGE_FORMAT_CLASS icd_format_get_class(VK_FORMAT format); +VkImageFormatClass icd_format_get_class(VkFormat format); -unsigned int icd_format_get_channel_count(VK_FORMAT format); +unsigned int icd_format_get_channel_count(VkFormat format); -void icd_format_get_raw_value(VK_FORMAT format, +void icd_format_get_raw_value(VkFormat format, const uint32_t color[4], void *value); diff --git a/icd/common/icd-instance.c b/icd/common/icd-instance.c index fed138e7..6d6c2cf4 100644 --- a/icd/common/icd-instance.c +++ b/icd/common/icd-instance.c @@ -33,7 +33,7 @@ static void * VKAPI default_alloc(void *user_data, size_t size, size_t alignment, - VK_SYSTEM_ALLOC_TYPE allocType) + VkSystemAllocType allocType) { if (alignment <= 1) { return malloc(size); @@ -61,10 +61,10 @@ static void VKAPI default_free(void *user_data, void *ptr) free(ptr); } -struct icd_instance *icd_instance_create(const VK_APPLICATION_INFO *app_info, - const VK_ALLOC_CALLBACKS *alloc_cb) +struct icd_instance *icd_instance_create(const VkApplicationInfo *app_info, + const VkAllocCallbacks *alloc_cb) { - static const VK_ALLOC_CALLBACKS default_alloc_cb = { + static const VkAllocCallbacks default_alloc_cb = { .pfnAlloc = default_alloc, .pfnFree = default_free, }; @@ -114,10 +114,10 @@ void icd_instance_destroy(struct icd_instance *instance) icd_instance_free(instance, instance); } -VK_RESULT icd_instance_set_bool(struct icd_instance *instance, +VkResult icd_instance_set_bool(struct icd_instance *instance, VK_DBG_GLOBAL_OPTION option, bool yes) { - VK_RESULT res = VK_SUCCESS; + VkResult res = VK_SUCCESS; switch (option) { case VK_DBG_OPTION_DEBUG_ECHO_ENABLE: @@ -137,7 +137,7 @@ VK_RESULT icd_instance_set_bool(struct icd_instance *instance, return res; } -VK_RESULT icd_instance_add_logger(struct icd_instance *instance, +VkResult icd_instance_add_logger(struct icd_instance *instance, VK_DBG_MSG_CALLBACK_FUNCTION func, void *user_data) { @@ -164,7 +164,7 @@ VK_RESULT icd_instance_add_logger(struct icd_instance *instance, return VK_SUCCESS; } -VK_RESULT icd_instance_remove_logger(struct icd_instance *instance, +VkResult icd_instance_remove_logger(struct icd_instance *instance, VK_DBG_MSG_CALLBACK_FUNCTION func) { struct icd_instance_logger *logger, *prev; @@ -190,8 +190,8 @@ VK_RESULT icd_instance_remove_logger(struct icd_instance *instance, void icd_instance_log(const struct icd_instance *instance, VK_DBG_MSG_TYPE msg_type, - VK_VALIDATION_LEVEL validation_level, - VK_BASE_OBJECT src_object, + VkValidationLevel validation_level, + VkBaseObject 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 9b7093cf..13a146ba 100644 --- a/icd/common/icd-instance.h +++ b/icd/common/icd-instance.h @@ -49,21 +49,21 @@ struct icd_instance { bool break_on_error; bool break_on_warning; - VK_ALLOC_CALLBACKS alloc_cb; + VkAllocCallbacks alloc_cb; struct icd_instance_logger *loggers; }; -struct icd_instance *icd_instance_create(const VK_APPLICATION_INFO *app_info, - const VK_ALLOC_CALLBACKS *alloc_cb); +struct icd_instance *icd_instance_create(const VkApplicationInfo *app_info, + const VkAllocCallbacks *alloc_cb); void icd_instance_destroy(struct icd_instance *instance); -VK_RESULT icd_instance_set_bool(struct icd_instance *instance, +VkResult icd_instance_set_bool(struct icd_instance *instance, VK_DBG_GLOBAL_OPTION option, bool yes); static inline void *icd_instance_alloc(const struct icd_instance *instance, size_t size, size_t alignment, - VK_SYSTEM_ALLOC_TYPE type) + VkSystemAllocType type) { return instance->alloc_cb.pfnAlloc(instance->alloc_cb.pUserData, size, alignment, type); @@ -75,16 +75,16 @@ static inline void icd_instance_free(const struct icd_instance *instance, instance->alloc_cb.pfnFree(instance->alloc_cb.pUserData, ptr); } -VK_RESULT icd_instance_add_logger(struct icd_instance *instance, +VkResult icd_instance_add_logger(struct icd_instance *instance, VK_DBG_MSG_CALLBACK_FUNCTION func, void *user_data); -VK_RESULT icd_instance_remove_logger(struct icd_instance *instance, +VkResult icd_instance_remove_logger(struct icd_instance *instance, VK_DBG_MSG_CALLBACK_FUNCTION func); void icd_instance_log(const struct icd_instance *instance, VK_DBG_MSG_TYPE msg_type, - VK_VALIDATION_LEVEL validation_level, - VK_BASE_OBJECT src_object, + VkValidationLevel validation_level, + VkBaseObject 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 7aac1704..12e73649 100644 --- a/icd/nulldrv/nulldrv.c +++ b/icd/nulldrv/nulldrv.c @@ -44,23 +44,23 @@ static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = { [NULLDRV_EXT_WSI_WINDOWS] = "VK_WSI_WINDOWS" }; -static struct nulldrv_base *nulldrv_base(VK_BASE_OBJECT base) +static struct nulldrv_base *nulldrv_base(VkBaseObject base) { return (struct nulldrv_base *) base; } -static VK_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type, +static VkResult nulldrv_base_get_info(struct nulldrv_base *base, int type, size_t *size, void *data) { - VK_RESULT ret = VK_SUCCESS; + VkResult ret = VK_SUCCESS; size_t s; uint32_t *count; switch (type) { case VK_INFO_TYPE_MEMORY_REQUIREMENTS: { - VK_MEMORY_REQUIREMENTS *mem_req = data; - s = sizeof(VK_MEMORY_REQUIREMENTS); + VkMemoryRequirements *mem_req = data; + s = sizeof(VkMemoryRequirements); *size = s; if (data == NULL) return ret; @@ -76,14 +76,14 @@ static VK_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type, *count = 1; break; case VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS: - s = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS); + s = sizeof(VkImageMemoryRequirements); *size = s; if (data == NULL) return ret; memset(data, 0, s); break; case VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS: - s = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS); + s = sizeof(VkBufferMemoryRequirements); *size = s; if (data == NULL) return ret; @@ -131,7 +131,7 @@ static struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev, return base; } -static VK_RESULT nulldrv_gpu_add(int devid, const char *primary_node, +static VkResult nulldrv_gpu_add(int devid, const char *primary_node, const char *render_node, struct nulldrv_gpu **gpu_ret) { struct nulldrv_gpu *gpu; @@ -149,7 +149,7 @@ static VK_RESULT nulldrv_gpu_add(int devid, const char *primary_node, return VK_SUCCESS; } -static VK_RESULT nulldrv_queue_create(struct nulldrv_dev *dev, +static VkResult nulldrv_queue_create(struct nulldrv_dev *dev, uint32_t node_index, struct nulldrv_queue **queue_ret) { @@ -167,7 +167,7 @@ static VK_RESULT nulldrv_queue_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT dev_create_queues(struct nulldrv_dev *dev, +static VkResult dev_create_queues(struct nulldrv_dev *dev, const VkDeviceQueueCreateInfo *queues, uint32_t count) { @@ -178,7 +178,7 @@ static VK_RESULT dev_create_queues(struct nulldrv_dev *dev, for (i = 0; i < count; i++) { const VkDeviceQueueCreateInfo *q = &queues[i]; - VK_RESULT ret = VK_SUCCESS; + VkResult ret = VK_SUCCESS; if (q->queueCount == 1 && !dev->queues[q->queueNodeIndex]) { ret = nulldrv_queue_create(dev, q->queueNodeIndex, @@ -211,7 +211,7 @@ static enum nulldrv_ext_type nulldrv_gpu_lookup_extension(const struct nulldrv_g return type; } -static VK_RESULT nulldrv_desc_ooxx_create(struct nulldrv_dev *dev, +static VkResult nulldrv_desc_ooxx_create(struct nulldrv_dev *dev, struct nulldrv_desc_ooxx **ooxx_ret) { struct nulldrv_desc_ooxx *ooxx; @@ -230,13 +230,13 @@ static VK_RESULT nulldrv_desc_ooxx_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_dev_create(struct nulldrv_gpu *gpu, +static VkResult nulldrv_dev_create(struct nulldrv_gpu *gpu, const VkDeviceCreateInfo *info, struct nulldrv_dev **dev_ret) { struct nulldrv_dev *dev; uint32_t i; - VK_RESULT ret; + VkResult ret; dev = (struct nulldrv_dev *) nulldrv_base_create(NULL, sizeof(*dev), VK_DBG_OBJECT_DEVICE); @@ -269,13 +269,13 @@ static VK_RESULT nulldrv_dev_create(struct nulldrv_gpu *gpu, return VK_SUCCESS; } -static struct nulldrv_gpu *nulldrv_gpu(VK_PHYSICAL_GPU gpu) +static struct nulldrv_gpu *nulldrv_gpu(VkPhysicalGpu gpu) { return (struct nulldrv_gpu *) gpu; } -static VK_RESULT nulldrv_rt_view_create(struct nulldrv_dev *dev, - const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO *info, +static VkResult nulldrv_rt_view_create(struct nulldrv_dev *dev, + const VkColorAttachmentViewCreateInfo *info, struct nulldrv_rt_view **view_ret) { struct nulldrv_rt_view *view; @@ -290,8 +290,8 @@ static VK_RESULT nulldrv_rt_view_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_fence_create(struct nulldrv_dev *dev, - const VK_FENCE_CREATE_INFO *info, +static VkResult nulldrv_fence_create(struct nulldrv_dev *dev, + const VkFenceCreateInfo *info, struct nulldrv_fence **fence_ret) { struct nulldrv_fence *fence; @@ -306,7 +306,7 @@ static VK_RESULT nulldrv_fence_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static struct nulldrv_dev *nulldrv_dev(VK_DEVICE dev) +static struct nulldrv_dev *nulldrv_dev(VkDevice dev) { return (struct nulldrv_dev *) dev; } @@ -317,18 +317,18 @@ static struct nulldrv_img *nulldrv_img_from_base(struct nulldrv_base *base) } -static VK_RESULT img_get_info(struct nulldrv_base *base, int type, +static VkResult img_get_info(struct nulldrv_base *base, int type, size_t *size, void *data) { struct nulldrv_img *img = nulldrv_img_from_base(base); - VK_RESULT ret = VK_SUCCESS; + VkResult ret = VK_SUCCESS; switch (type) { case VK_INFO_TYPE_MEMORY_REQUIREMENTS: { - VK_MEMORY_REQUIREMENTS *mem_req = data; + VkMemoryRequirements *mem_req = data; - *size = sizeof(VK_MEMORY_REQUIREMENTS); + *size = sizeof(VkMemoryRequirements); if (data == NULL) return ret; mem_req->size = img->total_size; @@ -338,9 +338,9 @@ static VK_RESULT img_get_info(struct nulldrv_base *base, int type, break; case VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS: { - VK_IMAGE_MEMORY_REQUIREMENTS *img_req = data; + VkImageMemoryRequirements *img_req = data; - *size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS); + *size = sizeof(VkImageMemoryRequirements); if (data == NULL) return ret; img_req->usage = img->usage; @@ -350,9 +350,9 @@ static VK_RESULT img_get_info(struct nulldrv_base *base, int type, break; case VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS: { - VK_BUFFER_MEMORY_REQUIREMENTS *buf_req = data; + VkBufferMemoryRequirements *buf_req = data; - *size = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS); + *size = sizeof(VkBufferMemoryRequirements); if (data == NULL) return ret; buf_req->usage = img->usage; @@ -366,8 +366,8 @@ static VK_RESULT img_get_info(struct nulldrv_base *base, int type, return ret; } -static VK_RESULT nulldrv_img_create(struct nulldrv_dev *dev, - const VK_IMAGE_CREATE_INFO *info, +static VkResult nulldrv_img_create(struct nulldrv_dev *dev, + const VkImageCreateInfo *info, bool scanout, struct nulldrv_img **img_ret) { @@ -396,12 +396,12 @@ static VK_RESULT nulldrv_img_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static struct nulldrv_img *nulldrv_img(VK_IMAGE image) +static struct nulldrv_img *nulldrv_img(VkImage image) { return (struct nulldrv_img *) image; } -static VK_RESULT nulldrv_mem_alloc(struct nulldrv_dev *dev, +static VkResult nulldrv_mem_alloc(struct nulldrv_dev *dev, const VkMemoryAllocInfo *info, struct nulldrv_mem **mem_ret) { @@ -424,8 +424,8 @@ static VK_RESULT nulldrv_mem_alloc(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev, - const VK_DEPTH_STENCIL_VIEW_CREATE_INFO *info, +static VkResult nulldrv_ds_view_create(struct nulldrv_dev *dev, + const VkDepthStencilViewCreateInfo *info, struct nulldrv_ds_view **view_ret) { struct nulldrv_img *img = nulldrv_img(info->image); @@ -445,8 +445,8 @@ static VK_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_sampler_create(struct nulldrv_dev *dev, - const VK_SAMPLER_CREATE_INFO *info, +static VkResult nulldrv_sampler_create(struct nulldrv_dev *dev, + const VkSamplerCreateInfo *info, struct nulldrv_sampler **sampler_ret) { struct nulldrv_sampler *sampler; @@ -461,8 +461,8 @@ static VK_RESULT nulldrv_sampler_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev, - const VK_IMAGE_VIEW_CREATE_INFO *info, +static VkResult nulldrv_img_view_create(struct nulldrv_dev *dev, + const VkImageViewCreateInfo *info, struct nulldrv_img_view **view_ret) { struct nulldrv_img *img = nulldrv_img(info->image); @@ -483,12 +483,12 @@ static VK_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static void *nulldrv_mem_map(struct nulldrv_mem *mem, VK_FLAGS flags) +static void *nulldrv_mem_map(struct nulldrv_mem *mem, VkFlags flags) { return mem->bo; } -static struct nulldrv_mem *nulldrv_mem(VK_GPU_MEMORY mem) +static struct nulldrv_mem *nulldrv_mem(VkGpuMemory mem) { return (struct nulldrv_mem *) mem; } @@ -498,18 +498,18 @@ static struct nulldrv_buf *nulldrv_buf_from_base(struct nulldrv_base *base) return (struct nulldrv_buf *) base; } -static VK_RESULT buf_get_info(struct nulldrv_base *base, int type, +static VkResult buf_get_info(struct nulldrv_base *base, int type, size_t *size, void *data) { struct nulldrv_buf *buf = nulldrv_buf_from_base(base); - VK_RESULT ret = VK_SUCCESS; + VkResult ret = VK_SUCCESS; switch (type) { case VK_INFO_TYPE_MEMORY_REQUIREMENTS: { - VK_MEMORY_REQUIREMENTS *mem_req = data; + VkMemoryRequirements *mem_req = data; - *size = sizeof(VK_MEMORY_REQUIREMENTS); + *size = sizeof(VkMemoryRequirements); if (data == NULL) return ret; @@ -521,9 +521,9 @@ static VK_RESULT buf_get_info(struct nulldrv_base *base, int type, break; case VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS: { - VK_BUFFER_MEMORY_REQUIREMENTS *buf_req = data; + VkBufferMemoryRequirements *buf_req = data; - *size = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS); + *size = sizeof(VkBufferMemoryRequirements); if (data == NULL) return ret; buf_req->usage = buf->usage; @@ -537,7 +537,7 @@ static VK_RESULT buf_get_info(struct nulldrv_base *base, int type, return ret; } -static VK_RESULT nulldrv_buf_create(struct nulldrv_dev *dev, +static VkResult nulldrv_buf_create(struct nulldrv_dev *dev, const VkBufferCreateInfo *info, struct nulldrv_buf **buf_ret) { @@ -558,8 +558,8 @@ static VK_RESULT nulldrv_buf_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_desc_layout_create(struct nulldrv_dev *dev, - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info, +static VkResult nulldrv_desc_layout_create(struct nulldrv_dev *dev, + const VkDescriptorSetLayoutCreateInfo *info, struct nulldrv_desc_layout **layout_ret) { struct nulldrv_desc_layout *layout; @@ -575,9 +575,9 @@ static VK_RESULT nulldrv_desc_layout_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_desc_layout_chain_create(struct nulldrv_dev *dev, +static VkResult nulldrv_desc_layout_chain_create(struct nulldrv_dev *dev, uint32_t setLayoutArrayCount, - const VK_DESCRIPTOR_SET_LAYOUT *pSetLayoutArray, + const VkDescriptorSetLayout *pSetLayoutArray, struct nulldrv_desc_layout_chain **chain_ret) { struct nulldrv_desc_layout_chain *chain; @@ -593,13 +593,13 @@ static VK_RESULT nulldrv_desc_layout_chain_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static struct nulldrv_desc_layout *nulldrv_desc_layout(VK_DESCRIPTOR_SET_LAYOUT layout) +static struct nulldrv_desc_layout *nulldrv_desc_layout(VkDescriptorSetLayout layout) { return (struct nulldrv_desc_layout *) layout; } -static VK_RESULT shader_create(struct nulldrv_dev *dev, - const VK_SHADER_CREATE_INFO *info, +static VkResult shader_create(struct nulldrv_dev *dev, + const VkShaderCreateInfo *info, struct nulldrv_shader **sh_ret) { struct nulldrv_shader *sh; @@ -614,8 +614,8 @@ static VK_RESULT shader_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT graphics_pipeline_create(struct nulldrv_dev *dev, - const VK_GRAPHICS_PIPELINE_CREATE_INFO *info_, +static VkResult graphics_pipeline_create(struct nulldrv_dev *dev, + const VkGraphicsPipelineCreateInfo *info_, struct nulldrv_pipeline **pipeline_ret) { struct nulldrv_pipeline *pipeline; @@ -631,8 +631,8 @@ static VK_RESULT graphics_pipeline_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_viewport_state_create(struct nulldrv_dev *dev, - const VK_DYNAMIC_VP_STATE_CREATE_INFO *info, +static VkResult nulldrv_viewport_state_create(struct nulldrv_dev *dev, + const VkDynamicVpStateCreateInfo *info, struct nulldrv_dynamic_vp **state_ret) { struct nulldrv_dynamic_vp *state; @@ -647,8 +647,8 @@ static VK_RESULT nulldrv_viewport_state_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_raster_state_create(struct nulldrv_dev *dev, - const VK_DYNAMIC_RS_STATE_CREATE_INFO *info, +static VkResult nulldrv_raster_state_create(struct nulldrv_dev *dev, + const VkDynamicRsStateCreateInfo *info, struct nulldrv_dynamic_rs **state_ret) { struct nulldrv_dynamic_rs *state; @@ -663,8 +663,8 @@ static VK_RESULT nulldrv_raster_state_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_blend_state_create(struct nulldrv_dev *dev, - const VK_DYNAMIC_CB_STATE_CREATE_INFO *info, +static VkResult nulldrv_blend_state_create(struct nulldrv_dev *dev, + const VkDynamicCbStateCreateInfo *info, struct nulldrv_dynamic_cb **state_ret) { struct nulldrv_dynamic_cb *state; @@ -679,8 +679,8 @@ static VK_RESULT nulldrv_blend_state_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_ds_state_create(struct nulldrv_dev *dev, - const VK_DYNAMIC_DS_STATE_CREATE_INFO *info, +static VkResult nulldrv_ds_state_create(struct nulldrv_dev *dev, + const VkDynamicDsStateCreateInfo *info, struct nulldrv_dynamic_ds **state_ret) { struct nulldrv_dynamic_ds *state; @@ -696,8 +696,8 @@ static VK_RESULT nulldrv_ds_state_create(struct nulldrv_dev *dev, } -static VK_RESULT nulldrv_cmd_create(struct nulldrv_dev *dev, - const VK_CMD_BUFFER_CREATE_INFO *info, +static VkResult nulldrv_cmd_create(struct nulldrv_dev *dev, + const VkCmdBufferCreateInfo *info, struct nulldrv_cmd **cmd_ret) { struct nulldrv_cmd *cmd; @@ -712,10 +712,10 @@ static VK_RESULT nulldrv_cmd_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_desc_pool_create(struct nulldrv_dev *dev, - VK_DESCRIPTOR_POOL_USAGE usage, +static VkResult nulldrv_desc_pool_create(struct nulldrv_dev *dev, + VkDescriptorPoolUsage usage, uint32_t max_sets, - const VK_DESCRIPTOR_POOL_CREATE_INFO *info, + const VkDescriptorPoolCreateInfo *info, struct nulldrv_desc_pool **pool_ret) { struct nulldrv_desc_pool *pool; @@ -733,9 +733,9 @@ static VK_RESULT nulldrv_desc_pool_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VK_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev, +static VkResult nulldrv_desc_set_create(struct nulldrv_dev *dev, struct nulldrv_desc_pool *pool, - VK_DESCRIPTOR_SET_USAGE usage, + VkDescriptorSetUsage usage, const struct nulldrv_desc_layout *layout, struct nulldrv_desc_set **set_ret) { @@ -754,13 +754,13 @@ static VK_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static struct nulldrv_desc_pool *nulldrv_desc_pool(VK_DESCRIPTOR_POOL pool) +static struct nulldrv_desc_pool *nulldrv_desc_pool(VkDescriptorPool pool) { return (struct nulldrv_desc_pool *) pool; } -static VK_RESULT nulldrv_fb_create(struct nulldrv_dev *dev, - const VK_FRAMEBUFFER_CREATE_INFO* info, +static VkResult nulldrv_fb_create(struct nulldrv_dev *dev, + const VkFramebufferCreateInfo* info, struct nulldrv_framebuffer ** fb_ret) { @@ -776,8 +776,8 @@ static VK_RESULT nulldrv_fb_create(struct nulldrv_dev *dev, } -static VK_RESULT nulldrv_render_pass_create(struct nulldrv_dev *dev, - const VK_RENDER_PASS_CREATE_INFO* info, +static VkResult nulldrv_render_pass_create(struct nulldrv_dev *dev, + const VkRenderPassCreateInfo* info, struct nulldrv_render_pass** rp_ret) { struct nulldrv_render_pass *rp; @@ -791,12 +791,12 @@ static VK_RESULT nulldrv_render_pass_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static struct nulldrv_buf *nulldrv_buf(VK_BUFFER buf) +static struct nulldrv_buf *nulldrv_buf(VkBuffer buf) { return (struct nulldrv_buf *) buf; } -static VK_RESULT nulldrv_buf_view_create(struct nulldrv_dev *dev, +static VkResult nulldrv_buf_view_create(struct nulldrv_dev *dev, const VkBufferViewCreateInfo *info, struct nulldrv_buf_view **view_ret) { @@ -820,10 +820,10 @@ static VK_RESULT nulldrv_buf_view_create(struct nulldrv_dev *dev, // Driver entry points //********************************************* -ICD_EXPORT VK_RESULT VKAPI vkCreateBuffer( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkCreateBuffer( + VkDevice device, const VkBufferCreateInfo* pCreateInfo, - VK_BUFFER* pBuffer) + VkBuffer* pBuffer) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -831,10 +831,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateBuffer( return nulldrv_buf_create(dev, pCreateInfo, (struct nulldrv_buf **) pBuffer); } -ICD_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer( - VK_DEVICE device, - const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, - VK_CMD_BUFFER* pCmdBuffer) +ICD_EXPORT VkResult VKAPI vkCreateCommandBuffer( + VkDevice device, + const VkCmdBufferCreateInfo* pCreateInfo, + VkCmdBuffer* pCmdBuffer) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -843,31 +843,31 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer( (struct nulldrv_cmd **) pCmdBuffer); } -ICD_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer( - VK_CMD_BUFFER cmdBuffer, - const VK_CMD_BUFFER_BEGIN_INFO *info) +ICD_EXPORT VkResult VKAPI vkBeginCommandBuffer( + VkCmdBuffer cmdBuffer, + const VkCmdBufferBeginInfo *info) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkEndCommandBuffer( - VK_CMD_BUFFER cmdBuffer) +ICD_EXPORT VkResult VKAPI vkEndCommandBuffer( + VkCmdBuffer cmdBuffer) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkResetCommandBuffer( - VK_CMD_BUFFER cmdBuffer) +ICD_EXPORT VkResult VKAPI vkResetCommandBuffer( + VkCmdBuffer cmdBuffer) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } ICD_EXPORT void VKAPI vkCmdInitAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) @@ -876,181 +876,181 @@ ICD_EXPORT void VKAPI vkCmdInitAtomicCounters( } ICD_EXPORT void VKAPI vkCmdLoadAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - VK_BUFFER srcBuffer, - VK_GPU_SIZE srcOffset) + VkBuffer srcBuffer, + VkGpuSize srcOffset) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdSaveAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset) + VkBuffer destBuffer, + VkGpuSize destOffset) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdDbgMarkerBegin( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, const char* pMarker) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdDbgMarkerEnd( - VK_CMD_BUFFER cmdBuffer) + VkCmdBuffer cmdBuffer) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdCopyBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_BUFFER destBuffer, + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkBuffer destBuffer, uint32_t regionCount, - const VK_BUFFER_COPY* pRegions) + const VkBufferCopy* pRegions) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdCopyImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t regionCount, - const VK_IMAGE_COPY* pRegions) + const VkImageCopy* pRegions) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdBlitImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t regionCount, - const VK_IMAGE_BLIT* pRegions) + const VkImageBlit* pRegions) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdCopyBufferToImage( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions) + const VkBufferImageCopy* pRegions) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdCopyImageToBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer destBuffer, uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions) + const VkBufferImageCopy* pRegions) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdCloneImageData( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout) + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdUpdateBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset, - VK_GPU_SIZE dataSize, + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkGpuSize destOffset, + VkGpuSize dataSize, const uint32_t* pData) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdFillBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset, - VK_GPU_SIZE fillSize, + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkGpuSize destOffset, + VkGpuSize fillSize, uint32_t data) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdClearColorImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + VkClearColor color, uint32_t rangeCount, - const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) + const VkImageSubresourceRange* pRanges) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdClearDepthStencil( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, - const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) + const VkImageSubresourceRange* pRanges) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdResolveImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t rectCount, - const VK_IMAGE_RESOLVE* pRects) + const VkImageResolve* pRects) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdBeginQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, uint32_t slot, - VK_FLAGS flags) + VkFlags flags) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdEndQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, uint32_t slot) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdResetQueryPool( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { @@ -1058,78 +1058,78 @@ ICD_EXPORT void VKAPI vkCmdResetQueryPool( } ICD_EXPORT void VKAPI vkCmdSetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event_, - VK_PIPE_EVENT pipeEvent) + VkCmdBuffer cmdBuffer, + VkEvent event_, + VkPipeEvent pipeEvent) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdResetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event_, - VK_PIPE_EVENT pipeEvent) + VkCmdBuffer cmdBuffer, + VkEvent event_, + VkPipeEvent pipeEvent) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdWriteTimestamp( - VK_CMD_BUFFER cmdBuffer, - VK_TIMESTAMP_TYPE timestampType, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset) + VkCmdBuffer cmdBuffer, + VkTimestampType timestampType, + VkBuffer destBuffer, + VkGpuSize destOffset) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdBindPipeline( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_PIPELINE pipeline) + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdBindDynamicStateObject( - VK_CMD_BUFFER cmdBuffer, - VK_STATE_BIND_POINT stateBindPoint, - VK_DYNAMIC_STATE_OBJECT state) + VkCmdBuffer cmdBuffer, + VkStateBindPoint stateBindPoint, + VkDynamicStateObject state) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdBindDescriptorSets( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets, + const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdBindVertexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, uint32_t binding) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdBindIndexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - VK_INDEX_TYPE indexType) + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, + VkIndexType indexType) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdDraw( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, @@ -1139,7 +1139,7 @@ ICD_EXPORT void VKAPI vkCmdDraw( } ICD_EXPORT void VKAPI vkCmdDrawIndexed( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, @@ -1150,9 +1150,9 @@ ICD_EXPORT void VKAPI vkCmdDrawIndexed( } ICD_EXPORT void VKAPI vkCmdDrawIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, uint32_t count, uint32_t stride) { @@ -1160,9 +1160,9 @@ ICD_EXPORT void VKAPI vkCmdDrawIndirect( } ICD_EXPORT void VKAPI vkCmdDrawIndexedIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, uint32_t count, uint32_t stride) { @@ -1170,7 +1170,7 @@ ICD_EXPORT void VKAPI vkCmdDrawIndexedIndirect( } ICD_EXPORT void VKAPI vkCmdDispatch( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) @@ -1179,49 +1179,49 @@ ICD_EXPORT void VKAPI vkCmdDispatch( } ICD_EXPORT void VKAPI vkCmdDispatchIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset) + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdWaitEvents( - VK_CMD_BUFFER cmdBuffer, - const VK_EVENT_WAIT_INFO* pWaitInfo) + VkCmdBuffer cmdBuffer, + const VkEventWaitInfo* pWaitInfo) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdPipelineBarrier( - VK_CMD_BUFFER cmdBuffer, - const VK_PIPELINE_BARRIER* pBarrier) + VkCmdBuffer cmdBuffer, + const VkPipelineBarrier* pBarrier) { NULLDRV_LOG_FUNC; } -ICD_EXPORT VK_RESULT VKAPI vkCreateDevice( - VK_PHYSICAL_GPU gpu_, +ICD_EXPORT VkResult VKAPI vkCreateDevice( + VkPhysicalGpu gpu_, const VkDeviceCreateInfo* pCreateInfo, - VK_DEVICE* pDevice) + VkDevice* pDevice) { NULLDRV_LOG_FUNC; struct nulldrv_gpu *gpu = nulldrv_gpu(gpu_); return nulldrv_dev_create(gpu, pCreateInfo, (struct nulldrv_dev**)pDevice); } -ICD_EXPORT VK_RESULT VKAPI vkDestroyDevice( - VK_DEVICE device) +ICD_EXPORT VkResult VKAPI vkDestroyDevice( + VkDevice device) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetDeviceQueue( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkGetDeviceQueue( + VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, - VK_QUEUE* pQueue) + VkQueue* pQueue) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1229,23 +1229,23 @@ ICD_EXPORT VK_RESULT VKAPI vkGetDeviceQueue( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle( - VK_DEVICE device) +ICD_EXPORT VkResult VKAPI vkDeviceWaitIdle( + VkDevice device) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel( - VK_DEVICE device, - VK_VALIDATION_LEVEL validationLevel) +ICD_EXPORT VkResult VKAPI vkDbgSetValidationLevel( + VkDevice device, + VkValidationLevel validationLevel) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkDbgSetMessageFilter( + VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter) { @@ -1253,8 +1253,8 @@ ICD_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkDbgSetDeviceOption( + VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) @@ -1263,40 +1263,40 @@ ICD_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateEvent( - VK_DEVICE device, - const VK_EVENT_CREATE_INFO* pCreateInfo, - VK_EVENT* pEvent) +ICD_EXPORT VkResult VKAPI vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + VkEvent* pEvent) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetEventStatus( - VK_EVENT event_) +ICD_EXPORT VkResult VKAPI vkGetEventStatus( + VkEvent event_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkSetEvent( - VK_EVENT event_) +ICD_EXPORT VkResult VKAPI vkSetEvent( + VkEvent event_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkResetEvent( - VK_EVENT event_) +ICD_EXPORT VkResult VKAPI vkResetEvent( + VkEvent event_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateFence( - VK_DEVICE device, - const VK_FENCE_CREATE_INFO* pCreateInfo, - VK_FENCE* pFence) +ICD_EXPORT VkResult VKAPI vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1305,26 +1305,26 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateFence( (struct nulldrv_fence **) pFence); } -ICD_EXPORT VK_RESULT VKAPI vkGetFenceStatus( - VK_FENCE fence_) +ICD_EXPORT VkResult VKAPI vkGetFenceStatus( + VkFence fence_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkResetFences( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkResetFences( + VkDevice device, uint32_t fenceCount, - VK_FENCE* pFences) + VkFence* pFences) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkWaitForFences( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkWaitForFences( + VkDevice device, uint32_t fenceCount, - const VK_FENCE* pFences, + const VkFence* pFences, bool32_t waitAll, uint64_t timeout) { @@ -1332,10 +1332,10 @@ ICD_EXPORT VK_RESULT VKAPI vkWaitForFences( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetFormatInfo( - VK_DEVICE device, - VK_FORMAT format, - VK_FORMAT_INFO_TYPE infoType, +ICD_EXPORT VkResult VKAPI vkGetFormatInfo( + VkDevice device, + VkFormat format, + VkFormatInfoType infoType, size_t* pDataSize, void* pData) { @@ -1343,9 +1343,9 @@ ICD_EXPORT VK_RESULT VKAPI vkGetFormatInfo( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetGpuInfo( - VK_PHYSICAL_GPU gpu_, - VK_PHYSICAL_GPU_INFO_TYPE infoType, +ICD_EXPORT VkResult VKAPI vkGetGpuInfo( + VkPhysicalGpu gpu_, + VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData) { @@ -1353,37 +1353,37 @@ ICD_EXPORT VK_RESULT VKAPI vkGetGpuInfo( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetExtensionSupport( - VK_PHYSICAL_GPU gpu_, +ICD_EXPORT VkResult VKAPI vkGetExtensionSupport( + VkPhysicalGpu gpu_, const char* pExtName) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility( - VK_PHYSICAL_GPU gpu0_, - VK_PHYSICAL_GPU gpu1_, - VK_GPU_COMPATIBILITY_INFO* pInfo) +ICD_EXPORT VkResult VKAPI vkGetMultiGpuCompatibility( + VkPhysicalGpu gpu0_, + VkPhysicalGpu gpu1_, + VkGpuCompatibilityInfo* pInfo) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkOpenPeerImage( - VK_DEVICE device, - const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, - VK_IMAGE* pImage, - VK_GPU_MEMORY* pMem) +ICD_EXPORT VkResult VKAPI vkOpenPeerImage( + VkDevice device, + const VkPeerImageOpenInfo* pOpenInfo, + VkImage* pImage, + VkGpuMemory* pMem) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateImage( - VK_DEVICE device, - const VK_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage) +ICD_EXPORT VkResult VKAPI vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + VkImage* pImage) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1392,22 +1392,22 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateImage( (struct nulldrv_img **) pImage); } -ICD_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo( - VK_IMAGE image, - const VK_IMAGE_SUBRESOURCE* pSubresource, - VK_SUBRESOURCE_INFO_TYPE infoType, +ICD_EXPORT VkResult VKAPI vkGetImageSubresourceInfo( + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) { NULLDRV_LOG_FUNC; - VK_RESULT ret = VK_SUCCESS; + VkResult ret = VK_SUCCESS; switch (infoType) { case VK_INFO_TYPE_SUBRESOURCE_LAYOUT: { - VK_SUBRESOURCE_LAYOUT *layout = (VK_SUBRESOURCE_LAYOUT *) pData; + VkSubresourceLayout *layout = (VkSubresourceLayout *) pData; - *pDataSize = sizeof(VK_SUBRESOURCE_LAYOUT); + *pDataSize = sizeof(VkSubresourceLayout); if (pData == NULL) return ret; @@ -1425,10 +1425,10 @@ ICD_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo( return ret; } -ICD_EXPORT VK_RESULT VKAPI vkAllocMemory( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkAllocMemory( + VkDevice device, const VkMemoryAllocInfo* pAllocInfo, - VK_GPU_MEMORY* pMem) + VkGpuMemory* pMem) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1436,24 +1436,24 @@ ICD_EXPORT VK_RESULT VKAPI vkAllocMemory( return nulldrv_mem_alloc(dev, pAllocInfo, (struct nulldrv_mem **) pMem); } -ICD_EXPORT VK_RESULT VKAPI vkFreeMemory( - VK_GPU_MEMORY mem_) +ICD_EXPORT VkResult VKAPI vkFreeMemory( + VkGpuMemory mem_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkSetMemoryPriority( - VK_GPU_MEMORY mem_, - VK_MEMORY_PRIORITY priority) +ICD_EXPORT VkResult VKAPI vkSetMemoryPriority( + VkGpuMemory mem_, + VkMemoryPriority priority) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkMapMemory( - VK_GPU_MEMORY mem_, - VK_FLAGS flags, +ICD_EXPORT VkResult VKAPI vkMapMemory( + VkGpuMemory mem_, + VkFlags flags, void** ppData) { NULLDRV_LOG_FUNC; @@ -1465,44 +1465,44 @@ ICD_EXPORT VK_RESULT VKAPI vkMapMemory( return (ptr) ? VK_SUCCESS : VK_ERROR_UNKNOWN; } -ICD_EXPORT VK_RESULT VKAPI vkUnmapMemory( - VK_GPU_MEMORY mem_) +ICD_EXPORT VkResult VKAPI vkUnmapMemory( + VkGpuMemory mem_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkPinSystemMemory( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkPinSystemMemory( + VkDevice device, const void* pSysMem, size_t memSize, - VK_GPU_MEMORY* pMem) + VkGpuMemory* pMem) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkOpenSharedMemory( - VK_DEVICE device, - const VK_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem) +ICD_EXPORT VkResult VKAPI vkOpenSharedMemory( + VkDevice device, + const VkMemoryOpenInfo* pOpenInfo, + VkGpuMemory* pMem) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkOpenPeerMemory( - VK_DEVICE device, - const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem) +ICD_EXPORT VkResult VKAPI vkOpenPeerMemory( + VkDevice device, + const VkPeerMemoryOpenInfo* pOpenInfo, + VkGpuMemory* pMem) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateInstance( +ICD_EXPORT VkResult VKAPI vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, - VK_INSTANCE* pInstance) + VkInstance* pInstance) { NULLDRV_LOG_FUNC; struct nulldrv_instance *inst; @@ -1514,36 +1514,36 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateInstance( inst->obj.base.get_info = NULL; - *pInstance = (VK_INSTANCE*)inst; + *pInstance = (VkInstance*)inst; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDestroyInstance( - VK_INSTANCE pInstance) +ICD_EXPORT VkResult VKAPI vkDestroyInstance( + VkInstance pInstance) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkEnumerateGpus( - VK_INSTANCE instance, +ICD_EXPORT VkResult VKAPI vkEnumerateGpus( + VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, - VK_PHYSICAL_GPU* pGpus) + VkPhysicalGpu* pGpus) { NULLDRV_LOG_FUNC; - VK_RESULT ret; + VkResult ret; struct nulldrv_gpu *gpu; *pGpuCount = 1; ret = nulldrv_gpu_add(0, 0, 0, &gpu); if (ret == VK_SUCCESS) - pGpus[0] = (VK_PHYSICAL_GPU) gpu; + pGpus[0] = (VkPhysicalGpu) gpu; return ret; } -ICD_EXPORT VK_RESULT VKAPI vkEnumerateLayers( - VK_PHYSICAL_GPU gpu, +ICD_EXPORT VkResult VKAPI vkEnumerateLayers( + VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, @@ -1554,8 +1554,8 @@ ICD_EXPORT VK_RESULT VKAPI vkEnumerateLayers( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback( - VK_INSTANCE instance, +ICD_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback( + VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { @@ -1563,16 +1563,16 @@ ICD_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback( - VK_INSTANCE instance, +ICD_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback( + VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption( - VK_INSTANCE instance, +ICD_EXPORT VkResult VKAPI vkDbgSetGlobalOption( + VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) @@ -1581,16 +1581,16 @@ ICD_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDestroyObject( - VK_OBJECT object) +ICD_EXPORT VkResult VKAPI vkDestroyObject( + VkObject object) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetObjectInfo( - VK_BASE_OBJECT object, - VK_OBJECT_INFO_TYPE infoType, +ICD_EXPORT VkResult VKAPI vkGetObjectInfo( + VkBaseObject object, + VkObjectInfoType infoType, size_t* pDataSize, void* pData) { @@ -1600,41 +1600,41 @@ ICD_EXPORT VK_RESULT VKAPI vkGetObjectInfo( return base->get_info(base, infoType, pDataSize, pData); } -ICD_EXPORT VK_RESULT VKAPI vkBindObjectMemory( - VK_OBJECT object, +ICD_EXPORT VkResult VKAPI vkBindObjectMemory( + VkObject object, uint32_t allocationIdx, - VK_GPU_MEMORY mem_, - VK_GPU_SIZE memOffset) + VkGpuMemory mem_, + VkGpuSize memOffset) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange( - VK_OBJECT object, +ICD_EXPORT VkResult VKAPI vkBindObjectMemoryRange( + VkObject object, uint32_t allocationIdx, - VK_GPU_SIZE rangeOffset, - VK_GPU_SIZE rangeSize, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset) + VkGpuSize rangeOffset, + VkGpuSize rangeSize, + VkGpuMemory mem, + VkGpuSize memOffset) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange( - VK_IMAGE image, +ICD_EXPORT VkResult VKAPI vkBindImageMemoryRange( + VkImage image, uint32_t allocationIdx, - const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset) + const VkImageMemoryBindInfo* bindInfo, + VkGpuMemory mem, + VkGpuSize memOffset) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag( - VK_BASE_OBJECT object, +ICD_EXPORT VkResult VKAPI vkDbgSetObjectTag( + VkBaseObject object, size_t tagSize, const void* pTag) { @@ -1642,10 +1642,10 @@ ICD_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline) +ICD_EXPORT VkResult VKAPI vkCreateGraphicsPipeline( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline* pPipeline) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1654,11 +1654,11 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline( (struct nulldrv_pipeline **) pPipeline); } -ICD_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline) +ICD_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline basePipeline, + VkPipeline* pPipeline) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1667,17 +1667,17 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( (struct nulldrv_pipeline **) pPipeline); } -ICD_EXPORT VK_RESULT VKAPI vkCreateComputePipeline( - VK_DEVICE device, - const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline) +ICD_EXPORT VkResult VKAPI vkCreateComputePipeline( + VkDevice device, + const VkComputePipelineCreateInfo* pCreateInfo, + VkPipeline* pPipeline) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkStorePipeline( - VK_PIPELINE pipeline, +ICD_EXPORT VkResult VKAPI vkStorePipeline( + VkPipeline pipeline, size_t* pDataSize, void* pData) { @@ -1685,38 +1685,38 @@ ICD_EXPORT VK_RESULT VKAPI vkStorePipeline( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkLoadPipeline( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkLoadPipeline( + VkDevice device, size_t dataSize, const void* pData, - VK_PIPELINE* pPipeline) + VkPipeline* pPipeline) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkLoadPipelineDerivative( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkLoadPipelineDerivative( + VkDevice device, size_t dataSize, const void* pData, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline) + VkPipeline basePipeline, + VkPipeline* pPipeline) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateQueryPool( - VK_DEVICE device, - const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, - VK_QUERY_POOL* pQueryPool) +ICD_EXPORT VkResult VKAPI vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults( - VK_QUERY_POOL queryPool, +ICD_EXPORT VkResult VKAPI vkGetQueryPoolResults( + VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, @@ -1726,77 +1726,77 @@ ICD_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults( return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkQueueAddMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem) +ICD_EXPORT VkResult VKAPI vkQueueAddMemReference( + VkQueue queue, + VkGpuMemory mem) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem) +ICD_EXPORT VkResult VKAPI vkQueueRemoveMemReference( + VkQueue queue, + VkGpuMemory mem) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkQueueWaitIdle( - VK_QUEUE queue_) +ICD_EXPORT VkResult VKAPI vkQueueWaitIdle( + VkQueue queue_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkQueueSubmit( - VK_QUEUE queue_, +ICD_EXPORT VkResult VKAPI vkQueueSubmit( + VkQueue queue_, uint32_t cmdBufferCount, - const VK_CMD_BUFFER* pCmdBuffers, - VK_FENCE fence_) + const VkCmdBuffer* pCmdBuffers, + VkFence fence_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, - VK_SEMAPHORE* pSemaphore) +ICD_EXPORT VkResult VKAPI vkOpenSharedSemaphore( + VkDevice device, + const VkSemaphoreOpenInfo* pOpenInfo, + VkSemaphore* pSemaphore) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, - VK_SEMAPHORE* pSemaphore) +ICD_EXPORT VkResult VKAPI vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + VkSemaphore* pSemaphore) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore) +ICD_EXPORT VkResult VKAPI vkQueueSignalSemaphore( + VkQueue queue, + VkSemaphore semaphore) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore) +ICD_EXPORT VkResult VKAPI vkQueueWaitSemaphore( + VkQueue queue, + VkSemaphore semaphore) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateSampler( - VK_DEVICE device, - const VK_SAMPLER_CREATE_INFO* pCreateInfo, - VK_SAMPLER* pSampler) +ICD_EXPORT VkResult VKAPI vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + VkSampler* pSampler) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1805,10 +1805,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateSampler( (struct nulldrv_sampler **) pSampler); } -ICD_EXPORT VK_RESULT VKAPI vkCreateShader( - VK_DEVICE device, - const VK_SHADER_CREATE_INFO* pCreateInfo, - VK_SHADER* pShader) +ICD_EXPORT VkResult VKAPI vkCreateShader( + VkDevice device, + const VkShaderCreateInfo* pCreateInfo, + VkShader* pShader) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1816,10 +1816,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateShader( return shader_create(dev, pCreateInfo, (struct nulldrv_shader **) pShader); } -ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState( - VK_DEVICE device, - const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_VP_STATE_OBJECT* pState) +ICD_EXPORT VkResult VKAPI vkCreateDynamicViewportState( + VkDevice device, + const VkDynamicVpStateCreateInfo* pCreateInfo, + VkDynamicVpStateObject* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1828,10 +1828,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState( (struct nulldrv_dynamic_vp **) pState); } -ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState( - VK_DEVICE device, - const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_RS_STATE_OBJECT* pState) +ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterState( + VkDevice device, + const VkDynamicRsStateCreateInfo* pCreateInfo, + VkDynamicRsStateObject* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1840,10 +1840,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState( (struct nulldrv_dynamic_rs **) pState); } -ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState( - VK_DEVICE device, - const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_CB_STATE_OBJECT* pState) +ICD_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState( + VkDevice device, + const VkDynamicCbStateCreateInfo* pCreateInfo, + VkDynamicCbStateObject* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1852,10 +1852,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState( (struct nulldrv_dynamic_cb **) pState); } -ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState( - VK_DEVICE device, - const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_DS_STATE_OBJECT* pState) +ICD_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState( + VkDevice device, + const VkDynamicDsStateCreateInfo* pCreateInfo, + VkDynamicDsStateObject* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1864,10 +1864,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState( (struct nulldrv_dynamic_ds **) pState); } -ICD_EXPORT VK_RESULT VKAPI vkCreateBufferView( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkCreateBufferView( + VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, - VK_BUFFER_VIEW* pView) + VkBufferView* pView) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1876,10 +1876,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateBufferView( (struct nulldrv_buf_view **) pView); } -ICD_EXPORT VK_RESULT VKAPI vkCreateImageView( - VK_DEVICE device, - const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, - VK_IMAGE_VIEW* pView) +ICD_EXPORT VkResult VKAPI vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + VkImageView* pView) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1888,10 +1888,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateImageView( (struct nulldrv_img_view **) pView); } -ICD_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView( - VK_DEVICE device, - const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - VK_COLOR_ATTACHMENT_VIEW* pView) +ICD_EXPORT VkResult VKAPI vkCreateColorAttachmentView( + VkDevice device, + const VkColorAttachmentViewCreateInfo* pCreateInfo, + VkColorAttachmentView* pView) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1900,10 +1900,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView( (struct nulldrv_rt_view **) pView); } -ICD_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView( - VK_DEVICE device, - const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, - VK_DEPTH_STENCIL_VIEW* pView) +ICD_EXPORT VkResult VKAPI vkCreateDepthStencilView( + VkDevice device, + const VkDepthStencilViewCreateInfo* pCreateInfo, + VkDepthStencilView* pView) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1913,10 +1913,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView( } -ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( - VK_DEVICE device, - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_SET_LAYOUT* pSetLayout) +ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayout* pSetLayout) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1925,11 +1925,11 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( (struct nulldrv_desc_layout **) pSetLayout); } -ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain( - VK_DEVICE device, +ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayoutChain( + VkDevice device, uint32_t setLayoutArrayCount, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain) + const VkDescriptorSetLayout* pSetLayoutArray, + VkDescriptorSetLayoutChain* pLayoutChain) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1939,28 +1939,28 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain( (struct nulldrv_desc_layout_chain **) pLayoutChain); } -ICD_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate( - VK_DEVICE device, - VK_DESCRIPTOR_UPDATE_MODE updateMode) +ICD_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate( + VkDevice device, + VkDescriptorUpdateMode updateMode) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate( - VK_DEVICE device, - VK_CMD_BUFFER cmd_) +ICD_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate( + VkDevice device, + VkCmdBuffer cmd_) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool( - VK_DEVICE device, - VK_DESCRIPTOR_POOL_USAGE poolUsage, +ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool( + VkDevice device, + VkDescriptorPoolUsage poolUsage, uint32_t maxSets, - const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_POOL* pDescriptorPool) + const VkDescriptorPoolCreateInfo* pCreateInfo, + VkDescriptorPool* pDescriptorPool) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -1969,30 +1969,30 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool( (struct nulldrv_desc_pool **) pDescriptorPool); } -ICD_EXPORT VK_RESULT VKAPI vkResetDescriptorPool( - VK_DESCRIPTOR_POOL descriptorPool) +ICD_EXPORT VkResult VKAPI vkResetDescriptorPool( + VkDescriptorPool descriptorPool) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, - VK_DESCRIPTOR_SET_USAGE setUsage, +ICD_EXPORT VkResult VKAPI vkAllocDescriptorSets( + VkDescriptorPool descriptorPool, + VkDescriptorSetUsage setUsage, uint32_t count, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, - VK_DESCRIPTOR_SET* pDescriptorSets, + const VkDescriptorSetLayout* pSetLayouts, + VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { NULLDRV_LOG_FUNC; struct nulldrv_desc_pool *pool = nulldrv_desc_pool(descriptorPool); struct nulldrv_dev *dev = pool->dev; - VK_RESULT ret = VK_SUCCESS; + VkResult ret = VK_SUCCESS; uint32_t i; for (i = 0; i < count; i++) { const struct nulldrv_desc_layout *layout = - nulldrv_desc_layout((VK_DESCRIPTOR_SET_LAYOUT) pSetLayouts[i]); + nulldrv_desc_layout((VkDescriptorSetLayout) pSetLayouts[i]); ret = nulldrv_desc_set_create(dev, pool, setUsage, layout, (struct nulldrv_desc_set **) &pDescriptorSets[i]); @@ -2007,25 +2007,25 @@ ICD_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets( } ICD_EXPORT void VKAPI vkClearDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, + VkDescriptorPool descriptorPool, uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets) + const VkDescriptorSet* pDescriptorSets) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkUpdateDescriptors( - VK_DESCRIPTOR_SET descriptorSet, + VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { NULLDRV_LOG_FUNC; } -ICD_EXPORT VK_RESULT VKAPI vkCreateFramebuffer( - VK_DEVICE device, - const VK_FRAMEBUFFER_CREATE_INFO* info, - VK_FRAMEBUFFER* fb_ret) +ICD_EXPORT VkResult VKAPI vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* info, + VkFramebuffer* fb_ret) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -2034,10 +2034,10 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateFramebuffer( } -ICD_EXPORT VK_RESULT VKAPI vkCreateRenderPass( - VK_DEVICE device, - const VK_RENDER_PASS_CREATE_INFO* info, - VK_RENDER_PASS* rp_ret) +ICD_EXPORT VkResult VKAPI vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* info, + VkRenderPass* rp_ret) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -2046,15 +2046,15 @@ ICD_EXPORT VK_RESULT VKAPI vkCreateRenderPass( } ICD_EXPORT void VKAPI vkCmdBeginRenderPass( - VK_CMD_BUFFER cmdBuffer, - const VK_RENDER_PASS_BEGIN* pRenderPassBegin) + VkCmdBuffer cmdBuffer, + const VkRenderPassBegin* pRenderPassBegin) { NULLDRV_LOG_FUNC; } ICD_EXPORT void VKAPI vkCmdEndRenderPass( - VK_CMD_BUFFER cmdBuffer, - VK_RENDER_PASS renderPass) + VkCmdBuffer cmdBuffer, + VkRenderPass renderPass) { NULLDRV_LOG_FUNC; } @@ -2080,7 +2080,7 @@ ICD_EXPORT int xcbGetMessage(void *msg) return 0; } -ICD_EXPORT VK_RESULT xcbQueuePresent(void *queue, void *image, void* fence) +ICD_EXPORT VkResult xcbQueuePresent(void *queue, void *image, void* fence) { return VK_SUCCESS; } diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h index 22af6c6c..daf45be9 100644 --- a/icd/nulldrv/nulldrv.h +++ b/icd/nulldrv/nulldrv.h @@ -48,7 +48,7 @@ struct nulldrv_base { void *loader_data; uint32_t magic; - VK_RESULT (*get_info)(struct nulldrv_base *base, int type1, + VkResult (*get_info)(struct nulldrv_base *base, int type1, size_t *size, void *data); }; @@ -100,12 +100,12 @@ struct nulldrv_fence { struct nulldrv_img { struct nulldrv_obj obj; - VK_IMAGE_TYPE type; + VkImageType type; int32_t depth; uint32_t mip_levels; uint32_t array_size; - VK_FLAGS usage; - VK_IMAGE_FORMAT_CLASS format_class; + VkFlags usage; + VkImageFormatClass format_class; uint32_t samples; size_t total_size; }; @@ -113,7 +113,7 @@ struct nulldrv_img { struct nulldrv_mem { struct nulldrv_base base; struct nulldrv_bo *bo; - VK_GPU_SIZE size; + VkGpuSize size; }; struct nulldrv_ds_view { @@ -135,8 +135,8 @@ struct nulldrv_img_view { struct nulldrv_buf { struct nulldrv_obj obj; - VK_GPU_SIZE size; - VK_FLAGS usage; + VkGpuSize size; + VkFlags usage; }; struct nulldrv_desc_layout { diff --git a/include/vkDbg.h b/include/vkDbg.h index fb224829..fcfdf318 100644 --- a/include/vkDbg.h +++ b/include/vkDbg.h @@ -101,66 +101,66 @@ typedef enum _VK_DBG_OBJECT_TYPE typedef void (VKAPI *VK_DBG_MSG_CALLBACK_FUNCTION)( VK_DBG_MSG_TYPE msgType, - VK_VALIDATION_LEVEL validationLevel, - VK_BASE_OBJECT srcObject, + VkValidationLevel validationLevel, + VkBaseObject srcObject, size_t location, int32_t msgCode, const char* pMsg, void* pUserData); // Debug functions -typedef VK_RESULT (VKAPI *vkDbgSetValidationLevelType)(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel); -typedef VK_RESULT (VKAPI *vkDbgRegisterMsgCallbackType)(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData); -typedef VK_RESULT (VKAPI *vkDbgUnregisterMsgCallbackType)(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); -typedef VK_RESULT (VKAPI *vkDbgSetMessageFilterType)(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter); -typedef VK_RESULT (VKAPI *vkDbgSetObjectTagType)(VK_BASE_OBJECT object, size_t tagSize, const void* pTag); -typedef VK_RESULT (VKAPI *vkDbgSetGlobalOptionType)(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData); -typedef VK_RESULT (VKAPI *vkDbgSetDeviceOptionType)(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData); -typedef void (VKAPI *vkCmdDbgMarkerBeginType)(VK_CMD_BUFFER cmdBuffer, const char* pMarker); -typedef void (VKAPI *vkCmdDbgMarkerEndType)(VK_CMD_BUFFER cmdBuffer); +typedef VkResult (VKAPI *PFN_vkDbgSetValidationLevel)(VkDevice device, VkValidationLevel validationLevel); +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_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); +typedef void (VKAPI *PFN_vkCmdDbgMarkerEnd)(VkCmdBuffer cmdBuffer); #ifdef VK_PROTOTYPES -VK_RESULT VKAPI vkDbgSetValidationLevel( - VK_DEVICE device, - VK_VALIDATION_LEVEL validationLevel); +VkResult VKAPI vkDbgSetValidationLevel( + VkDevice device, + VkValidationLevel validationLevel); -VK_RESULT VKAPI vkDbgRegisterMsgCallback( - VK_INSTANCE instance, +VkResult VKAPI vkDbgRegisterMsgCallback( + VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData); -VK_RESULT VKAPI vkDbgUnregisterMsgCallback( - VK_INSTANCE instance, +VkResult VKAPI vkDbgUnregisterMsgCallback( + VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback); -VK_RESULT VKAPI vkDbgSetMessageFilter( - VK_DEVICE device, +VkResult VKAPI vkDbgSetMessageFilter( + VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter); -VK_RESULT VKAPI vkDbgSetObjectTag( - VK_BASE_OBJECT object, +VkResult VKAPI vkDbgSetObjectTag( + VkBaseObject object, size_t tagSize, const void* pTag); -VK_RESULT VKAPI vkDbgSetGlobalOption( - VK_INSTANCE instance, +VkResult VKAPI vkDbgSetGlobalOption( + VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData); -VK_RESULT VKAPI vkDbgSetDeviceOption( - VK_DEVICE device, +VkResult VKAPI vkDbgSetDeviceOption( + VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData); void VKAPI vkCmdDbgMarkerBegin( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, const char* pMarker); void VKAPI vkCmdDbgMarkerEnd( - VK_CMD_BUFFER cmdBuffer); + VkCmdBuffer cmdBuffer); #endif // VK_PROTOTYPES diff --git a/include/vkLayer.h b/include/vkLayer.h index c3679a00..f5b6fac3 100644 --- a/include/vkLayer.h +++ b/include/vkLayer.h @@ -20,141 +20,141 @@ typedef struct _VK_BASE_LAYER_OBJECT { - vkGetProcAddrType pGPA; - VK_BASE_OBJECT nextObject; - VK_BASE_OBJECT baseObject; + PFN_vkGetProcAddr pGPA; + VkBaseObject nextObject; + VkBaseObject baseObject; } VK_BASE_LAYER_OBJECT; typedef struct _VK_LAYER_DISPATCH_TABLE { - vkGetProcAddrType GetProcAddr; - vkCreateInstanceType CreateInstance; - vkDestroyInstanceType DestroyInstance; - vkEnumerateGpusType EnumerateGpus; - vkGetGpuInfoType GetGpuInfo; - vkCreateDeviceType CreateDevice; - vkDestroyDeviceType DestroyDevice; - vkGetExtensionSupportType GetExtensionSupport; - vkEnumerateLayersType EnumerateLayers; - vkGetDeviceQueueType GetDeviceQueue; - vkQueueSubmitType QueueSubmit; - vkQueueAddMemReferenceType QueueAddMemReference; - vkQueueRemoveMemReferenceType QueueRemoveMemReference; - vkQueueWaitIdleType QueueWaitIdle; - vkDeviceWaitIdleType DeviceWaitIdle; - vkAllocMemoryType AllocMemory; - vkFreeMemoryType FreeMemory; - vkSetMemoryPriorityType SetMemoryPriority; - vkMapMemoryType MapMemory; - vkUnmapMemoryType UnmapMemory; - vkPinSystemMemoryType PinSystemMemory; - vkGetMultiGpuCompatibilityType GetMultiGpuCompatibility; - vkOpenSharedMemoryType OpenSharedMemory; - vkOpenSharedSemaphoreType OpenSharedSemaphore; - vkOpenPeerMemoryType OpenPeerMemory; - vkOpenPeerImageType OpenPeerImage; - vkDestroyObjectType DestroyObject; - vkGetObjectInfoType GetObjectInfo; - vkBindObjectMemoryType BindObjectMemory; - vkBindObjectMemoryRangeType BindObjectMemoryRange; - vkBindImageMemoryRangeType BindImageMemoryRange; - vkCreateFenceType CreateFence; - vkGetFenceStatusType GetFenceStatus; - vkResetFencesType ResetFences; - vkWaitForFencesType WaitForFences; - vkCreateSemaphoreType CreateSemaphore; - vkQueueSignalSemaphoreType QueueSignalSemaphore; - vkQueueWaitSemaphoreType QueueWaitSemaphore; - vkCreateEventType CreateEvent; - vkGetEventStatusType GetEventStatus; - vkSetEventType SetEvent; - vkResetEventType ResetEvent; - vkCreateQueryPoolType CreateQueryPool; - vkGetQueryPoolResultsType GetQueryPoolResults; - vkGetFormatInfoType GetFormatInfo; - vkCreateBufferType CreateBuffer; - vkCreateBufferViewType CreateBufferView; - vkCreateImageType CreateImage; - vkGetImageSubresourceInfoType GetImageSubresourceInfo; - vkCreateImageViewType CreateImageView; - vkCreateColorAttachmentViewType CreateColorAttachmentView; - vkCreateDepthStencilViewType CreateDepthStencilView; - vkCreateShaderType CreateShader; - vkCreateGraphicsPipelineType CreateGraphicsPipeline; - vkCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative; - vkCreateComputePipelineType CreateComputePipeline; - vkStorePipelineType StorePipeline; - vkLoadPipelineType LoadPipeline; - vkLoadPipelineDerivativeType LoadPipelineDerivative; - vkCreateSamplerType CreateSampler; - vkCreateDescriptorSetLayoutType CreateDescriptorSetLayout; - vkCreateDescriptorSetLayoutChainType CreateDescriptorSetLayoutChain; - vkBeginDescriptorPoolUpdateType BeginDescriptorPoolUpdate; - vkEndDescriptorPoolUpdateType EndDescriptorPoolUpdate; - vkCreateDescriptorPoolType CreateDescriptorPool; - vkResetDescriptorPoolType ResetDescriptorPool; - vkAllocDescriptorSetsType AllocDescriptorSets; - vkClearDescriptorSetsType ClearDescriptorSets; - vkUpdateDescriptorsType UpdateDescriptors; - vkCreateDynamicViewportStateType CreateDynamicViewportState; - vkCreateDynamicRasterStateType CreateDynamicRasterState; - vkCreateDynamicColorBlendStateType CreateDynamicColorBlendState; - vkCreateDynamicDepthStencilStateType CreateDynamicDepthStencilState; - vkCreateCommandBufferType CreateCommandBuffer; - vkBeginCommandBufferType BeginCommandBuffer; - vkEndCommandBufferType EndCommandBuffer; - vkResetCommandBufferType ResetCommandBuffer; - vkCmdBindPipelineType CmdBindPipeline; - vkCmdBindDynamicStateObjectType CmdBindDynamicStateObject; - vkCmdBindDescriptorSetsType CmdBindDescriptorSets; - vkCmdBindVertexBufferType CmdBindVertexBuffer; - vkCmdBindIndexBufferType CmdBindIndexBuffer; - vkCmdDrawType CmdDraw; - vkCmdDrawIndexedType CmdDrawIndexed; - vkCmdDrawIndirectType CmdDrawIndirect; - vkCmdDrawIndexedIndirectType CmdDrawIndexedIndirect; - vkCmdDispatchType CmdDispatch; - vkCmdDispatchIndirectType CmdDispatchIndirect; - vkCmdCopyBufferType CmdCopyBuffer; - vkCmdCopyImageType CmdCopyImage; - vkCmdBlitImageType CmdBlitImage; - vkCmdCopyBufferToImageType CmdCopyBufferToImage; - vkCmdCopyImageToBufferType CmdCopyImageToBuffer; - vkCmdCloneImageDataType CmdCloneImageData; - vkCmdUpdateBufferType CmdUpdateBuffer; - vkCmdFillBufferType CmdFillBuffer; - vkCmdClearColorImageType CmdClearColorImage; - vkCmdClearDepthStencilType CmdClearDepthStencil; - vkCmdResolveImageType CmdResolveImage; - vkCmdSetEventType CmdSetEvent; - vkCmdResetEventType CmdResetEvent; - vkCmdWaitEventsType CmdWaitEvents; - vkCmdPipelineBarrierType CmdPipelineBarrier; - vkCmdBeginQueryType CmdBeginQuery; - vkCmdEndQueryType CmdEndQuery; - vkCmdResetQueryPoolType CmdResetQueryPool; - vkCmdWriteTimestampType CmdWriteTimestamp; - vkCmdInitAtomicCountersType CmdInitAtomicCounters; - vkCmdLoadAtomicCountersType CmdLoadAtomicCounters; - vkCmdSaveAtomicCountersType CmdSaveAtomicCounters; - vkCreateFramebufferType CreateFramebuffer; - vkCreateRenderPassType CreateRenderPass; - vkCmdBeginRenderPassType CmdBeginRenderPass; - vkCmdEndRenderPassType CmdEndRenderPass; - vkDbgSetValidationLevelType DbgSetValidationLevel; - vkDbgRegisterMsgCallbackType DbgRegisterMsgCallback; - vkDbgUnregisterMsgCallbackType DbgUnregisterMsgCallback; - vkDbgSetMessageFilterType DbgSetMessageFilter; - vkDbgSetObjectTagType DbgSetObjectTag; - vkDbgSetGlobalOptionType DbgSetGlobalOption; - vkDbgSetDeviceOptionType DbgSetDeviceOption; - vkCmdDbgMarkerBeginType CmdDbgMarkerBegin; - vkCmdDbgMarkerEndType CmdDbgMarkerEnd; + PFN_vkGetProcAddr GetProcAddr; + PFN_vkCreateInstance CreateInstance; + PFN_vkDestroyInstance DestroyInstance; + PFN_vkEnumerateGpus EnumerateGpus; + PFN_vkGetGpuInfo GetGpuInfo; + PFN_vkCreateDevice CreateDevice; + PFN_vkDestroyDevice DestroyDevice; + PFN_vkGetExtensionSupport GetExtensionSupport; + PFN_vkEnumerateLayers EnumerateLayers; + PFN_vkGetDeviceQueue GetDeviceQueue; + PFN_vkQueueSubmit QueueSubmit; + PFN_vkQueueAddMemReference QueueAddMemReference; + PFN_vkQueueRemoveMemReference QueueRemoveMemReference; + PFN_vkQueueWaitIdle QueueWaitIdle; + PFN_vkDeviceWaitIdle DeviceWaitIdle; + PFN_vkAllocMemory AllocMemory; + PFN_vkFreeMemory FreeMemory; + PFN_vkSetMemoryPriority SetMemoryPriority; + PFN_vkMapMemory MapMemory; + PFN_vkUnmapMemory UnmapMemory; + PFN_vkPinSystemMemory PinSystemMemory; + PFN_vkGetMultiGpuCompatibility GetMultiGpuCompatibility; + PFN_vkOpenSharedMemory OpenSharedMemory; + PFN_vkOpenSharedSemaphore OpenSharedSemaphore; + PFN_vkOpenPeerMemory OpenPeerMemory; + PFN_vkOpenPeerImage OpenPeerImage; + PFN_vkDestroyObject DestroyObject; + PFN_vkGetObjectInfo GetObjectInfo; + PFN_vkBindObjectMemory BindObjectMemory; + PFN_vkBindObjectMemoryRange BindObjectMemoryRange; + PFN_vkBindImageMemoryRange BindImageMemoryRange; + PFN_vkCreateFence CreateFence; + PFN_vkGetFenceStatus GetFenceStatus; + PFN_vkResetFences ResetFences; + PFN_vkWaitForFences WaitForFences; + PFN_vkCreateSemaphore CreateSemaphore; + PFN_vkQueueSignalSemaphore QueueSignalSemaphore; + PFN_vkQueueWaitSemaphore QueueWaitSemaphore; + PFN_vkCreateEvent CreateEvent; + PFN_vkGetEventStatus GetEventStatus; + PFN_vkSetEvent SetEvent; + PFN_vkResetEvent ResetEvent; + PFN_vkCreateQueryPool CreateQueryPool; + PFN_vkGetQueryPoolResults GetQueryPoolResults; + PFN_vkGetFormatInfo GetFormatInfo; + PFN_vkCreateBuffer CreateBuffer; + PFN_vkCreateBufferView CreateBufferView; + PFN_vkCreateImage CreateImage; + PFN_vkGetImageSubresourceInfo GetImageSubresourceInfo; + PFN_vkCreateImageView CreateImageView; + PFN_vkCreateColorAttachmentView CreateColorAttachmentView; + PFN_vkCreateDepthStencilView CreateDepthStencilView; + PFN_vkCreateShader CreateShader; + PFN_vkCreateGraphicsPipeline CreateGraphicsPipeline; + PFN_vkCreateGraphicsPipelineDerivative CreateGraphicsPipelineDerivative; + PFN_vkCreateComputePipeline CreateComputePipeline; + PFN_vkStorePipeline StorePipeline; + PFN_vkLoadPipeline LoadPipeline; + PFN_vkLoadPipelineDerivative LoadPipelineDerivative; + PFN_vkCreateSampler CreateSampler; + PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout; + PFN_vkCreateDescriptorSetLayoutChain CreateDescriptorSetLayoutChain; + PFN_vkBeginDescriptorPoolUpdate BeginDescriptorPoolUpdate; + PFN_vkEndDescriptorPoolUpdate EndDescriptorPoolUpdate; + PFN_vkCreateDescriptorPool CreateDescriptorPool; + PFN_vkResetDescriptorPool ResetDescriptorPool; + PFN_vkAllocDescriptorSets AllocDescriptorSets; + PFN_vkClearDescriptorSets ClearDescriptorSets; + PFN_vkUpdateDescriptors UpdateDescriptors; + PFN_vkCreateDynamicViewportState CreateDynamicViewportState; + PFN_vkCreateDynamicRasterState CreateDynamicRasterState; + PFN_vkCreateDynamicColorBlendState CreateDynamicColorBlendState; + PFN_vkCreateDynamicDepthStencilState CreateDynamicDepthStencilState; + PFN_vkCreateCommandBuffer CreateCommandBuffer; + PFN_vkBeginCommandBuffer BeginCommandBuffer; + PFN_vkEndCommandBuffer EndCommandBuffer; + PFN_vkResetCommandBuffer ResetCommandBuffer; + PFN_vkCmdBindPipeline CmdBindPipeline; + PFN_vkCmdBindDynamicStateObject CmdBindDynamicStateObject; + PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets; + PFN_vkCmdBindVertexBuffer CmdBindVertexBuffer; + PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer; + PFN_vkCmdDraw CmdDraw; + PFN_vkCmdDrawIndexed CmdDrawIndexed; + PFN_vkCmdDrawIndirect CmdDrawIndirect; + PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect; + PFN_vkCmdDispatch CmdDispatch; + PFN_vkCmdDispatchIndirect CmdDispatchIndirect; + PFN_vkCmdCopyBuffer CmdCopyBuffer; + PFN_vkCmdCopyImage CmdCopyImage; + PFN_vkCmdBlitImage CmdBlitImage; + PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage; + PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer; + PFN_vkCmdCloneImageData CmdCloneImageData; + PFN_vkCmdUpdateBuffer CmdUpdateBuffer; + PFN_vkCmdFillBuffer CmdFillBuffer; + PFN_vkCmdClearColorImage CmdClearColorImage; + PFN_vkCmdClearDepthStencil CmdClearDepthStencil; + PFN_vkCmdResolveImage CmdResolveImage; + PFN_vkCmdSetEvent CmdSetEvent; + PFN_vkCmdResetEvent CmdResetEvent; + PFN_vkCmdWaitEvents CmdWaitEvents; + PFN_vkCmdPipelineBarrier CmdPipelineBarrier; + PFN_vkCmdBeginQuery CmdBeginQuery; + PFN_vkCmdEndQuery CmdEndQuery; + PFN_vkCmdResetQueryPool CmdResetQueryPool; + PFN_vkCmdWriteTimestamp CmdWriteTimestamp; + PFN_vkCmdInitAtomicCounters CmdInitAtomicCounters; + PFN_vkCmdLoadAtomicCounters CmdLoadAtomicCounters; + PFN_vkCmdSaveAtomicCounters CmdSaveAtomicCounters; + PFN_vkCreateFramebuffer CreateFramebuffer; + PFN_vkCreateRenderPass CreateRenderPass; + PFN_vkCmdBeginRenderPass CmdBeginRenderPass; + PFN_vkCmdEndRenderPass CmdEndRenderPass; + PFN_vkDbgSetValidationLevel DbgSetValidationLevel; + PFN_vkDbgRegisterMsgCallback DbgRegisterMsgCallback; + PFN_vkDbgUnregisterMsgCallback DbgUnregisterMsgCallback; + PFN_vkDbgSetMessageFilter DbgSetMessageFilter; + PFN_vkDbgSetObjectTag DbgSetObjectTag; + PFN_vkDbgSetGlobalOption DbgSetGlobalOption; + PFN_vkDbgSetDeviceOption DbgSetDeviceOption; + PFN_vkCmdDbgMarkerBegin CmdDbgMarkerBegin; + PFN_vkCmdDbgMarkerEnd CmdDbgMarkerEnd; #if defined(__linux__) || defined(XCB_NVIDIA) - vkWsiX11AssociateConnectionType WsiX11AssociateConnection; - vkWsiX11GetMSCType WsiX11GetMSC; - vkWsiX11CreatePresentableImageType WsiX11CreatePresentableImage; - vkWsiX11QueuePresentType WsiX11QueuePresent; + PFN_vkWsiX11AssociateConnection WsiX11AssociateConnection; + PFN_vkWsiX11GetMSC WsiX11GetMSC; + PFN_vkWsiX11CreatePresentableImage WsiX11CreatePresentableImage; + PFN_vkWsiX11QueuePresent WsiX11QueuePresent; #endif // WIN32 } VK_LAYER_DISPATCH_TABLE; diff --git a/include/vkWsiX11Ext.h b/include/vkWsiX11Ext.h index f7046375..2f1d6239 100644 --- a/include/vkWsiX11Ext.h +++ b/include/vkWsiX11Ext.h @@ -20,17 +20,17 @@ typedef struct _VK_WSI_X11_CONNECTION_INFO { typedef struct _VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO { - VK_FORMAT format; - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_EXTENT2D extent; - VK_FLAGS flags; + VkFormat format; + VkFlags usage; // VkImageUsageFlags + VkExtent2D extent; + VkFlags flags; } VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO; typedef struct _VK_WSI_X11_PRESENT_INFO { /* which window to present to */ xcb_window_t destWindow; - VK_IMAGE srcImage; + VkImage srcImage; /** * After the command buffers in the queue have been completed, if the MSC @@ -80,10 +80,10 @@ typedef struct _VK_WSI_X11_PRESENT_INFO bool32_t flip; } VK_WSI_X11_PRESENT_INFO; -typedef VK_RESULT (VKAPI *vkWsiX11AssociateConnectionType)(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); -typedef VK_RESULT (VKAPI *vkWsiX11GetMSCType)(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc); -typedef VK_RESULT (VKAPI *vkWsiX11CreatePresentableImageType)(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem); -typedef VK_RESULT (VKAPI *vkWsiX11QueuePresentType)(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence); +typedef VkResult (VKAPI *PFN_vkWsiX11AssociateConnection)(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); +typedef VkResult (VKAPI *PFN_vkWsiX11GetMSC)(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc); +typedef VkResult (VKAPI *PFN_vkWsiX11CreatePresentableImage)(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkWsiX11QueuePresent)(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence); /** * Associate an X11 connection with a GPU. This should be done before device @@ -97,8 +97,8 @@ typedef VK_RESULT (VKAPI *vkWsiX11QueuePresentType)(VK_QUEUE queue, const VK_WSI * This function is available when vkGetExtensionSupport says "VK_WSI_X11" * is supported. */ -VK_RESULT VKAPI vkWsiX11AssociateConnection( - VK_PHYSICAL_GPU gpu, +VkResult VKAPI vkWsiX11AssociateConnection( + VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo); /** @@ -106,23 +106,23 @@ VK_RESULT VKAPI vkWsiX11AssociateConnection( * of \p crtc. If crtc is \p XCB_NONE, a suitable CRTC is picked based on \p * win. */ -VK_RESULT VKAPI vkWsiX11GetMSC( - VK_DEVICE device, +VkResult VKAPI vkWsiX11GetMSC( + VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc); /** - * Create an VK_IMAGE that can be presented. An VK_GPU_MEMORY is created + * Create an VkImage that can be presented. An VkGpuMemory is created * and bound automatically. The memory returned can only be used in * vkQueue[Add|Remove]MemReference. Destroying the memory or binding another memory to the * image is not allowed. */ -VK_RESULT VKAPI vkWsiX11CreatePresentableImage( - VK_DEVICE device, +VkResult VKAPI vkWsiX11CreatePresentableImage( + VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage, - VK_GPU_MEMORY* pMem); + VkImage* pImage, + VkGpuMemory* pMem); /** * Present an image to an X11 window. The presentation always occurs after @@ -131,10 +131,10 @@ VK_RESULT VKAPI vkWsiX11CreatePresentableImage( * * Fence is reached when the presentation occurs. */ -VK_RESULT VKAPI vkWsiX11QueuePresent( - VK_QUEUE queue, +VkResult VKAPI vkWsiX11QueuePresent( + VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, - VK_FENCE fence); + VkFence fence); #ifdef __cplusplus } // extern "C" diff --git a/include/vk_platform.h b/include/vk_platform.h index fc73dd16..0f4927c7 100644 --- a/include/vk_platform.h +++ b/include/vk_platform.h @@ -76,11 +76,11 @@ extern "C" #endif #endif // !defined(VK_NO_STDINT_H) -typedef uint64_t VK_GPU_SIZE; +typedef uint64_t VkGpuSize; typedef uint32_t bool32_t; -typedef uint32_t VK_SAMPLE_MASK; -typedef uint32_t VK_FLAGS; +typedef uint32_t VkSampleMask; +typedef uint32_t VkFlags; typedef int32_t VK_ENUM; #ifdef __cplusplus diff --git a/include/vulkan.h b/include/vulkan.h index ef5ce640..bea82b06 100644 --- a/include/vulkan.h +++ b/include/vulkan.h @@ -54,38 +54,38 @@ extern "C" #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj; #endif // __cplusplus -VK_DEFINE_HANDLE(VK_INSTANCE) -VK_DEFINE_HANDLE(VK_PHYSICAL_GPU) -VK_DEFINE_HANDLE(VK_BASE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DEVICE, VK_BASE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_QUEUE, VK_BASE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_GPU_MEMORY, VK_BASE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_OBJECT, VK_BASE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER_VIEW, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE_VIEW, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_COLOR_ATTACHMENT_VIEW, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DEPTH_STENCIL_VIEW, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_SHADER, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_PIPELINE, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_SAMPLER, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT_CHAIN, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_POOL, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_STATE_OBJECT, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_VP_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_RS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_CB_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_DS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_CMD_BUFFER, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_FENCE, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_SEMAPHORE, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_EVENT, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_QUERY_POOL, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_FRAMEBUFFER, VK_OBJECT) -VK_DEFINE_SUBCLASS_HANDLE(VK_RENDER_PASS, VK_OBJECT) +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalGpu) +VK_DEFINE_HANDLE(VkBaseObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDevice, VkBaseObject) +VK_DEFINE_SUBCLASS_HANDLE(VkQueue, VkBaseObject) +VK_DEFINE_SUBCLASS_HANDLE(VkGpuMemory, 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(VkSampler, VkObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDescriptorSet, VkObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDescriptorSetLayoutChain, VkObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDescriptorPool, VkObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDynamicStateObject, VkObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDynamicVpStateObject, VkDynamicStateObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDynamicRsStateObject, VkDynamicStateObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDynamicCbStateObject, VkDynamicStateObject) +VK_DEFINE_SUBCLASS_HANDLE(VkDynamicDsStateObject, 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) #define VK_MAX_PHYSICAL_GPUS 16 #define VK_MAX_PHYSICAL_GPU_NAME 256 @@ -108,7 +108,7 @@ VK_DEFINE_SUBCLASS_HANDLE(VK_RENDER_PASS, VK_OBJECT) // Enumerations -typedef enum _VK_MEMORY_PRIORITY +typedef enum VkMemoryPriority_ { VK_MEMORY_PRIORITY_UNUSED = 0x0, VK_MEMORY_PRIORITY_VERY_LOW = 0x1, @@ -120,10 +120,10 @@ typedef enum _VK_MEMORY_PRIORITY VK_MEMORY_PRIORITY_BEGIN_RANGE = VK_MEMORY_PRIORITY_UNUSED, VK_MEMORY_PRIORITY_END_RANGE = VK_MEMORY_PRIORITY_VERY_HIGH, VK_NUM_MEMORY_PRIORITY = (VK_MEMORY_PRIORITY_END_RANGE - VK_MEMORY_PRIORITY_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_MEMORY_PRIORITY) -} VK_MEMORY_PRIORITY; + VK_MAX_ENUM(VkMemoryPriority_) +} VkMemoryPriority; -typedef enum _VK_IMAGE_LAYOUT +typedef enum VkImageLayout_ { VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) VK_IMAGE_LAYOUT_GENERAL = 0x00000001, // General layout when image can be used for any kind of access @@ -138,10 +138,10 @@ typedef enum _VK_IMAGE_LAYOUT VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, VK_NUM_IMAGE_LAYOUT = (VK_IMAGE_LAYOUT_END_RANGE - VK_IMAGE_LAYOUT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_IMAGE_LAYOUT) -} VK_IMAGE_LAYOUT; + VK_MAX_ENUM(VkImageLayout_) +} VkImageLayout; -typedef enum _VK_PIPE_EVENT +typedef enum VkPipeEvent_ { VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the GPU starts processing subsequent command VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete @@ -155,10 +155,10 @@ typedef enum _VK_PIPE_EVENT VK_PIPE_EVENT_BEGIN_RANGE = VK_PIPE_EVENT_TOP_OF_PIPE, VK_PIPE_EVENT_END_RANGE = VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE, VK_NUM_PIPE_EVENT = (VK_PIPE_EVENT_END_RANGE - VK_PIPE_EVENT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_PIPE_EVENT) -} VK_PIPE_EVENT; + VK_MAX_ENUM(VkPipeEvent_) +} VkPipeEvent; -typedef enum _VK_WAIT_EVENT +typedef enum VkWaitEvent_ { VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the GPU starts processing subsequent commands VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002, // Wait event before rasterizing subsequent primitives @@ -166,20 +166,20 @@ typedef enum _VK_WAIT_EVENT VK_WAIT_EVENT_BEGIN_RANGE = VK_WAIT_EVENT_TOP_OF_PIPE, VK_WAIT_EVENT_END_RANGE = VK_WAIT_EVENT_BEFORE_RASTERIZATION, VK_NUM_WAIT_EVENT = (VK_WAIT_EVENT_END_RANGE - VK_WAIT_EVENT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_WAIT_EVENT) -} VK_WAIT_EVENT; + VK_MAX_ENUM(VkWaitEvent_) +} VkWaitEvent; -typedef enum _VK_MEMORY_OUTPUT_FLAGS +typedef enum VkMemoryOutputFlags_ { VK_MEMORY_OUTPUT_CPU_WRITE_BIT = 0x00000001, // Controls output coherency of CPU writes VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, // Controls output coherency of generic shader writes VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, // Controls output coherency of color attachment writes VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, // Controls output coherency of depth/stencil attachment writes VK_MEMORY_OUTPUT_COPY_BIT = 0x00000010, // Controls output coherency of copy operations - VK_MAX_ENUM(_VK_MEMORY_OUTPUT_FLAGS) -} VK_MEMORY_OUTPUT_FLAGS; + VK_MAX_ENUM(VkMemoryOutputFlags_) +} VkMemoryOutputFlags; -typedef enum _VK_MEMORY_INPUT_FLAGS +typedef enum VkMemoryInputFlags_ { VK_MEMORY_INPUT_CPU_READ_BIT = 0x00000001, // Controls input coherency of CPU reads VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, // Controls input coherency of indirect command reads @@ -190,10 +190,10 @@ typedef enum _VK_MEMORY_INPUT_FLAGS VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, // Controls input coherency of color attachment reads VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, // Controls input coherency of depth/stencil attachment reads VK_MEMORY_INPUT_COPY_BIT = 0x00000100, // Controls input coherency of copy operations - VK_MAX_ENUM(_VK_MEMORY_INPUT_FLAGS) -} VK_MEMORY_INPUT_FLAGS; + VK_MAX_ENUM(VkMemoryInputFlags_) +} VkMemoryInputFlags; -typedef enum _VK_ATTACHMENT_LOAD_OP +typedef enum VkAttachmentLoadOp_ { VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000, VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001, @@ -202,10 +202,10 @@ typedef enum _VK_ATTACHMENT_LOAD_OP VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_NUM_ATTACHMENT_LOAD_OP = (VK_ATTACHMENT_LOAD_OP_END_RANGE - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_ATTACHMENT_LOAD_OP) -} VK_ATTACHMENT_LOAD_OP; + VK_MAX_ENUM(VkAttachmentLoadOp_) +} VkAttachmentLoadOp; -typedef enum _VK_ATTACHMENT_STORE_OP +typedef enum VkAttachmentStoreOp_ { VK_ATTACHMENT_STORE_OP_STORE = 0x00000000, VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001, @@ -214,10 +214,10 @@ typedef enum _VK_ATTACHMENT_STORE_OP VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_NUM_ATTACHMENT_STORE_OP = (VK_ATTACHMENT_STORE_OP_END_RANGE - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_ATTACHMENT_STORE_OP) -} VK_ATTACHMENT_STORE_OP; + VK_MAX_ENUM(VkAttachmentStoreOp_) +} VkAttachmentStoreOp; -typedef enum _VK_IMAGE_TYPE +typedef enum VkImageType_ { VK_IMAGE_1D = 0x00000000, VK_IMAGE_2D = 0x00000001, @@ -226,10 +226,10 @@ typedef enum _VK_IMAGE_TYPE VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_1D, VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_3D, VK_NUM_IMAGE_TYPE = (VK_IMAGE_TYPE_END_RANGE - VK_IMAGE_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_IMAGE_TYPE) -} VK_IMAGE_TYPE; + VK_MAX_ENUM(VkImageType_) +} VkImageType; -typedef enum _VK_IMAGE_TILING +typedef enum VkImageTiling_ { VK_LINEAR_TILING = 0x00000000, VK_OPTIMAL_TILING = 0x00000001, @@ -237,10 +237,10 @@ typedef enum _VK_IMAGE_TILING VK_IMAGE_TILING_BEGIN_RANGE = VK_LINEAR_TILING, VK_IMAGE_TILING_END_RANGE = VK_OPTIMAL_TILING, VK_NUM_IMAGE_TILING = (VK_IMAGE_TILING_END_RANGE - VK_IMAGE_TILING_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_IMAGE_TILING) -} VK_IMAGE_TILING; + VK_MAX_ENUM(VkImageTiling_) +} VkImageTiling; -typedef enum _VK_IMAGE_VIEW_TYPE +typedef enum VkImageViewType_ { VK_IMAGE_VIEW_1D = 0x00000000, VK_IMAGE_VIEW_2D = 0x00000001, @@ -250,10 +250,10 @@ typedef enum _VK_IMAGE_VIEW_TYPE VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_1D, VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_CUBE, VK_NUM_IMAGE_VIEW_TYPE = (VK_IMAGE_VIEW_TYPE_END_RANGE - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_IMAGE_VIEW_TYPE) -} VK_IMAGE_VIEW_TYPE; + VK_MAX_ENUM(VkImageViewType_) +} VkImageViewType; -typedef enum _VK_IMAGE_ASPECT +typedef enum VkImageAspect_ { VK_IMAGE_ASPECT_COLOR = 0x00000000, VK_IMAGE_ASPECT_DEPTH = 0x00000001, @@ -262,10 +262,10 @@ typedef enum _VK_IMAGE_ASPECT VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_STENCIL, VK_NUM_IMAGE_ASPECT = (VK_IMAGE_ASPECT_END_RANGE - VK_IMAGE_ASPECT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_IMAGE_ASPECT) -} VK_IMAGE_ASPECT; + VK_MAX_ENUM(VkImageAspect_) +} VkImageAspect; -typedef enum _VK_CHANNEL_SWIZZLE +typedef enum VkChannelSwizzle_ { VK_CHANNEL_SWIZZLE_ZERO = 0x00000000, VK_CHANNEL_SWIZZLE_ONE = 0x00000001, @@ -277,10 +277,10 @@ typedef enum _VK_CHANNEL_SWIZZLE VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, VK_NUM_CHANNEL_SWIZZLE = (VK_CHANNEL_SWIZZLE_END_RANGE - VK_CHANNEL_SWIZZLE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_CHANNEL_SWIZZLE) -} VK_CHANNEL_SWIZZLE; + VK_MAX_ENUM(VkChannelSwizzle_) +} VkChannelSwizzle; -typedef enum _VK_DESCRIPTOR_TYPE +typedef enum VkDescriptorType_ { VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000, VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE = 0x00000001, @@ -296,10 +296,10 @@ typedef enum _VK_DESCRIPTOR_TYPE VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC, VK_NUM_DESCRIPTOR_TYPE = (VK_DESCRIPTOR_TYPE_END_RANGE - VK_DESCRIPTOR_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_DESCRIPTOR_TYPE) -} VK_DESCRIPTOR_TYPE; + VK_MAX_ENUM(VkDescriptorType_) +} VkDescriptorType; -typedef enum _VK_DESCRIPTOR_POOL_USAGE +typedef enum VkDescriptorPoolUsage_ { VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000, VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001, @@ -307,10 +307,10 @@ typedef enum _VK_DESCRIPTOR_POOL_USAGE VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, VK_NUM_DESCRIPTOR_POOL_USAGE = (VK_DESCRIPTOR_POOL_USAGE_END_RANGE - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_DESCRIPTOR_POOL_USAGE) -} VK_DESCRIPTOR_POOL_USAGE; + VK_MAX_ENUM(VkDescriptorPoolUsage_) +} VkDescriptorPoolUsage; -typedef enum _VK_DESCRIPTOR_UPDATE_MODE +typedef enum VkDescriptorUpdateMode_ { VK_DESCRIPTOR_UDPATE_MODE_COPY = 0x00000000, VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001, @@ -318,10 +318,10 @@ typedef enum _VK_DESCRIPTOR_UPDATE_MODE VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE = VK_DESCRIPTOR_UDPATE_MODE_COPY, VK_DESCRIPTOR_UPDATE_MODE_END_RANGE = VK_DESCRIPTOR_UPDATE_MODE_FASTEST, VK_NUM_DESCRIPTOR_UPDATE_MODE = (VK_DESCRIPTOR_UPDATE_MODE_END_RANGE - VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_DESCRIPTOR_UPDATE_MODE) -} VK_DESCRIPTOR_UPDATE_MODE; + VK_MAX_ENUM(VkDescriptorUpdateMode_) +} VkDescriptorUpdateMode; -typedef enum _VK_DESCRIPTOR_SET_USAGE +typedef enum VkDescriptorSetUsage_ { VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000, VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001, @@ -329,10 +329,10 @@ typedef enum _VK_DESCRIPTOR_SET_USAGE VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, VK_NUM_DESCRIPTOR_SET_USAGE = (VK_DESCRIPTOR_SET_USAGE_END_RANGE - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_DESCRIPTOR_SET_USAGE) -} VK_DESCRIPTOR_SET_USAGE; + VK_MAX_ENUM(VkDescriptorSetUsage_) +} VkDescriptorSetUsage; -typedef enum _VK_QUERY_TYPE +typedef enum VkQueryType_ { VK_QUERY_OCCLUSION = 0x00000000, VK_QUERY_PIPELINE_STATISTICS = 0x00000001, @@ -340,10 +340,10 @@ typedef enum _VK_QUERY_TYPE VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_OCCLUSION, VK_QUERY_TYPE_END_RANGE = VK_QUERY_PIPELINE_STATISTICS, VK_NUM_QUERY_TYPE = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_QUERY_TYPE) -} VK_QUERY_TYPE; + VK_MAX_ENUM(VkQueryType_) +} VkQueryType; -typedef enum _VK_TIMESTAMP_TYPE +typedef enum VkTimestampType_ { VK_TIMESTAMP_TOP = 0x00000000, VK_TIMESTAMP_BOTTOM = 0x00000001, @@ -352,9 +352,9 @@ typedef enum _VK_TIMESTAMP_TYPE VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_BOTTOM, VK_NUM_TIMESTAMP_TYPE = (VK_TIMESTAMP_TYPE_END_RANGE - VK_TIMESTAMP_TYPE_BEGIN_RANGE + 1), VK_MAX_ENUM(_VK_TIMESTEAMP_TYPE) -} VK_TIMESTAMP_TYPE; +} VkTimestampType; -typedef enum _VK_BORDER_COLOR_TYPE +typedef enum VkBorderColorType_ { VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000, VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001, @@ -363,10 +363,10 @@ typedef enum _VK_BORDER_COLOR_TYPE VK_BORDER_COLOR_TYPE_BEGIN_RANGE = VK_BORDER_COLOR_OPAQUE_WHITE, VK_BORDER_COLOR_TYPE_END_RANGE = VK_BORDER_COLOR_OPAQUE_BLACK, VK_NUM_BORDER_COLOR_TYPE = (VK_BORDER_COLOR_TYPE_END_RANGE - VK_BORDER_COLOR_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_BORDER_COLOR_TYPE) -} VK_BORDER_COLOR_TYPE; + VK_MAX_ENUM(VkBorderColorType_) +} VkBorderColorType; -typedef enum _VK_PIPELINE_BIND_POINT +typedef enum VkPipelineBindPoint_ { VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000, VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001, @@ -374,10 +374,10 @@ typedef enum _VK_PIPELINE_BIND_POINT VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, VK_NUM_PIPELINE_BIND_POINT = (VK_PIPELINE_BIND_POINT_END_RANGE - VK_PIPELINE_BIND_POINT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_PIPELINE_BIND_POINT) -} VK_PIPELINE_BIND_POINT; + VK_MAX_ENUM(VkPipelineBindPoint_) +} VkPipelineBindPoint; -typedef enum _VK_STATE_BIND_POINT +typedef enum VkStateBindPoint_ { VK_STATE_BIND_VIEWPORT = 0x00000000, VK_STATE_BIND_RASTER = 0x00000001, @@ -387,10 +387,10 @@ typedef enum _VK_STATE_BIND_POINT VK_STATE_BIND_POINT_BEGIN_RANGE = VK_STATE_BIND_VIEWPORT, VK_STATE_BIND_POINT_END_RANGE = VK_STATE_BIND_DEPTH_STENCIL, VK_NUM_STATE_BIND_POINT = (VK_STATE_BIND_POINT_END_RANGE - VK_STATE_BIND_POINT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_STATE_BIND_POINT) -} VK_STATE_BIND_POINT; + VK_MAX_ENUM(VkStateBindPoint_) +} VkStateBindPoint; -typedef enum _VK_PRIMITIVE_TOPOLOGY +typedef enum VkPrimitiveTopology_ { VK_TOPOLOGY_POINT_LIST = 0x00000000, VK_TOPOLOGY_LINE_LIST = 0x00000001, @@ -407,10 +407,10 @@ typedef enum _VK_PRIMITIVE_TOPOLOGY VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_TOPOLOGY_PATCH, VK_NUM_PRIMITIVE_TOPOLOGY = (VK_PRIMITIVE_TOPOLOGY_END_RANGE - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_PRIMITIVE_TOPOLOGY) -} VK_PRIMITIVE_TOPOLOGY; + VK_MAX_ENUM(VkPrimitiveTopology_) +} VkPrimitiveTopology; -typedef enum _VK_INDEX_TYPE +typedef enum VkIndexType_ { VK_INDEX_8 = 0x00000000, VK_INDEX_16 = 0x00000001, @@ -419,10 +419,10 @@ typedef enum _VK_INDEX_TYPE VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_8, VK_INDEX_TYPE_END_RANGE = VK_INDEX_32, VK_NUM_INDEX_TYPE = (VK_INDEX_TYPE_END_RANGE - VK_INDEX_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_INDEX_TYPE) -} VK_INDEX_TYPE; + VK_MAX_ENUM(VkIndexType_) +} VkIndexType; -typedef enum _VK_TEX_FILTER +typedef enum VkTexFilter_ { VK_TEX_FILTER_NEAREST = 0, VK_TEX_FILTER_LINEAR = 1, @@ -430,10 +430,10 @@ typedef enum _VK_TEX_FILTER VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, VK_NUM_TEX_FILTER = (VK_TEX_FILTER_END_RANGE - VK_TEX_FILTER_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_TEX_FILTER) -} VK_TEX_FILTER; + VK_MAX_ENUM(VkTexFilter_) +} VkTexFilter; -typedef enum _VK_TEX_MIPMAP_MODE +typedef enum VkTexMipmapMode_ { VK_TEX_MIPMAP_BASE = 0, // Always choose base level VK_TEX_MIPMAP_NEAREST = 1, // Choose nearest mip level @@ -442,10 +442,10 @@ typedef enum _VK_TEX_MIPMAP_MODE VK_TEX_MIPMAP_BEGIN_RANGE = VK_TEX_MIPMAP_BASE, VK_TEX_MIPMAP_END_RANGE = VK_TEX_MIPMAP_LINEAR, VK_NUM_TEX_MIPMAP = (VK_TEX_MIPMAP_END_RANGE - VK_TEX_MIPMAP_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_TEX_MIPMAP_MODE) -} VK_TEX_MIPMAP_MODE; + VK_MAX_ENUM(VkTexMipmapMode_) +} VkTexMipmapMode; -typedef enum _VK_TEX_ADDRESS +typedef enum VkTexAddress_ { VK_TEX_ADDRESS_WRAP = 0x00000000, VK_TEX_ADDRESS_MIRROR = 0x00000001, @@ -456,10 +456,10 @@ typedef enum _VK_TEX_ADDRESS VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, VK_NUM_TEX_ADDRESS = (VK_TEX_ADDRESS_END_RANGE - VK_TEX_ADDRESS_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_TEX_ADDRESS) -} VK_TEX_ADDRESS; + VK_MAX_ENUM(VkTexAddress_) +} VkTexAddress; -typedef enum _VK_COMPARE_FUNC +typedef enum VkCompareFunc_ { VK_COMPARE_NEVER = 0x00000000, VK_COMPARE_LESS = 0x00000001, @@ -473,10 +473,10 @@ typedef enum _VK_COMPARE_FUNC VK_COMPARE_FUNC_BEGIN_RANGE = VK_COMPARE_NEVER, VK_COMPARE_FUNC_END_RANGE = VK_COMPARE_ALWAYS, VK_NUM_COMPARE_FUNC = (VK_COMPARE_FUNC_END_RANGE - VK_COMPARE_FUNC_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_COMPARE_FUNC) -} VK_COMPARE_FUNC; + VK_MAX_ENUM(VkCompareFunc_) +} VkCompareFunc; -typedef enum _VK_FILL_MODE +typedef enum VkFillMode_ { VK_FILL_POINTS = 0x00000000, VK_FILL_WIREFRAME = 0x00000001, @@ -485,10 +485,10 @@ typedef enum _VK_FILL_MODE VK_FILL_MODE_BEGIN_RANGE = VK_FILL_POINTS, VK_FILL_MODE_END_RANGE = VK_FILL_SOLID, VK_NUM_FILL_MODE = (VK_FILL_MODE_END_RANGE - VK_FILL_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_FILL_MODE) -} VK_FILL_MODE; + VK_MAX_ENUM(VkFillMode_) +} VkFillMode; -typedef enum _VK_CULL_MODE +typedef enum VkCullMode_ { VK_CULL_NONE = 0x00000000, VK_CULL_FRONT = 0x00000001, @@ -498,10 +498,10 @@ typedef enum _VK_CULL_MODE VK_CULL_MODE_BEGIN_RANGE = VK_CULL_NONE, VK_CULL_MODE_END_RANGE = VK_CULL_FRONT_AND_BACK, VK_NUM_CULL_MODE = (VK_CULL_MODE_END_RANGE - VK_CULL_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_CULL_MODE) -} VK_CULL_MODE; + VK_MAX_ENUM(VkCullMode_) +} VkCullMode; -typedef enum _VK_FACE_ORIENTATION +typedef enum VkFaceOrientation_ { VK_FRONT_FACE_CCW = 0x00000000, VK_FRONT_FACE_CW = 0x00000001, @@ -509,10 +509,10 @@ typedef enum _VK_FACE_ORIENTATION VK_FACE_ORIENTATION_BEGIN_RANGE = VK_FRONT_FACE_CCW, VK_FACE_ORIENTATION_END_RANGE = VK_FRONT_FACE_CW, VK_NUM_FACE_ORIENTATION = (VK_FACE_ORIENTATION_END_RANGE - VK_FACE_ORIENTATION_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_FACE_ORIENTATION) -} VK_FACE_ORIENTATION; + VK_MAX_ENUM(VkFaceOrientation_) +} VkFaceOrientation; -typedef enum _VK_PROVOKING_VERTEX_CONVENTION +typedef enum VkProvokingVertexConvention_ { VK_PROVOKING_VERTEX_FIRST = 0x00000000, VK_PROVOKING_VERTEX_LAST = 0x00000001, @@ -520,10 +520,10 @@ typedef enum _VK_PROVOKING_VERTEX_CONVENTION VK_PROVOKING_VERTEX_BEGIN_RANGE = VK_PROVOKING_VERTEX_FIRST, VK_PROVOKING_VERTEX_END_RANGE = VK_PROVOKING_VERTEX_LAST, VK_NUM_PROVOKING_VERTEX_CONVENTION = (VK_PROVOKING_VERTEX_END_RANGE - VK_PROVOKING_VERTEX_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_PROVOKING_VERTEX_CONVENTION) -} VK_PROVOKING_VERTEX_CONVENTION; + VK_MAX_ENUM(VkProvokingVertexConvention_) +} VkProvokingVertexConvention; -typedef enum _VK_COORDINATE_ORIGIN +typedef enum VkCoordinateOrigin_ { VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000, VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001, @@ -531,10 +531,10 @@ typedef enum _VK_COORDINATE_ORIGIN VK_COORDINATE_ORIGIN_BEGIN_RANGE = VK_COORDINATE_ORIGIN_UPPER_LEFT, VK_COORDINATE_ORIGIN_END_RANGE = VK_COORDINATE_ORIGIN_LOWER_LEFT, VK_NUM_COORDINATE_ORIGIN = (VK_COORDINATE_ORIGIN_END_RANGE - VK_COORDINATE_ORIGIN_END_RANGE + 1), - VK_MAX_ENUM(_VK_COORDINATE_ORIGIN) -} VK_COORDINATE_ORIGIN; + VK_MAX_ENUM(VkCoordinateOrigin_) +} VkCoordinateOrigin; -typedef enum _VK_DEPTH_MODE +typedef enum VkDepthMode_ { VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000, VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001, @@ -542,10 +542,10 @@ typedef enum _VK_DEPTH_MODE VK_DEPTH_MODE_BEGIN_RANGE = VK_DEPTH_MODE_ZERO_TO_ONE, VK_DEPTH_MODE_END_RANGE = VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE, VK_NUM_DEPTH_MODE = (VK_DEPTH_MODE_END_RANGE - VK_DEPTH_MODE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_DEPTH_MODE) -} VK_DEPTH_MODE; + VK_MAX_ENUM(VkDepthMode_) +} VkDepthMode; -typedef enum _VK_BLEND +typedef enum VkBlend_ { VK_BLEND_ZERO = 0x00000000, VK_BLEND_ONE = 0x00000001, @@ -570,10 +570,10 @@ typedef enum _VK_BLEND VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, VK_NUM_BLEND = (VK_BLEND_END_RANGE - VK_BLEND_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_BLEND) -} VK_BLEND; + VK_MAX_ENUM(VkBlend_) +} VkBlend; -typedef enum _VK_BLEND_FUNC +typedef enum VkBlendFunc_ { VK_BLEND_FUNC_ADD = 0x00000000, VK_BLEND_FUNC_SUBTRACT = 0x00000001, @@ -584,10 +584,10 @@ typedef enum _VK_BLEND_FUNC VK_BLEND_FUNC_BEGIN_RANGE = VK_BLEND_FUNC_ADD, VK_BLEND_FUNC_END_RANGE = VK_BLEND_FUNC_MAX, VK_NUM_BLEND_FUNC = (VK_BLEND_FUNC_END_RANGE - VK_BLEND_FUNC_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_BLEND_FUNC) -} VK_BLEND_FUNC; + VK_MAX_ENUM(VkBlendFunc_) +} VkBlendFunc; -typedef enum _VK_STENCIL_OP +typedef enum VkStencilOp_ { VK_STENCIL_OP_KEEP = 0x00000000, VK_STENCIL_OP_ZERO = 0x00000001, @@ -601,10 +601,10 @@ typedef enum _VK_STENCIL_OP VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, VK_NUM_STENCIL_OP = (VK_STENCIL_OP_END_RANGE - VK_STENCIL_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_STENCIL_OP) -} VK_STENCIL_OP; + VK_MAX_ENUM(VkStencilOp_) +} VkStencilOp; -typedef enum _VK_LOGIC_OP +typedef enum VkLogicOp_ { VK_LOGIC_OP_COPY = 0x00000000, VK_LOGIC_OP_CLEAR = 0x00000001, @@ -626,10 +626,10 @@ typedef enum _VK_LOGIC_OP VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_COPY, VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, VK_NUM_LOGIC_OP = (VK_LOGIC_OP_END_RANGE - VK_LOGIC_OP_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_LOGIC_OP) -} VK_LOGIC_OP; + VK_MAX_ENUM(VkLogicOp_) +} VkLogicOp; -typedef enum _VK_SYSTEM_ALLOC_TYPE +typedef enum VkSystemAllocType_ { VK_SYSTEM_ALLOC_API_OBJECT = 0x00000000, VK_SYSTEM_ALLOC_INTERNAL = 0x00000001, @@ -640,10 +640,10 @@ typedef enum _VK_SYSTEM_ALLOC_TYPE VK_SYSTEM_ALLOC_BEGIN_RANGE = VK_SYSTEM_ALLOC_API_OBJECT, VK_SYSTEM_ALLOC_END_RANGE = VK_SYSTEM_ALLOC_DEBUG, VK_NUM_SYSTEM_ALLOC_TYPE = (VK_SYSTEM_ALLOC_END_RANGE - VK_SYSTEM_ALLOC_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_SYSTEM_ALLOC_TYPE) -} VK_SYSTEM_ALLOC_TYPE; + VK_MAX_ENUM(VkSystemAllocType_) +} VkSystemAllocType; -typedef enum _VK_PHYSICAL_GPU_TYPE +typedef enum VkPhysicalGpuType_ { VK_GPU_TYPE_OTHER = 0x00000000, VK_GPU_TYPE_INTEGRATED = 0x00000001, @@ -653,10 +653,10 @@ typedef enum _VK_PHYSICAL_GPU_TYPE VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE = VK_GPU_TYPE_OTHER, VK_PHYSICAL_GPU_TYPE_END_RANGE = VK_GPU_TYPE_VIRTUAL, VK_NUM_PHYSICAL_GPU_TYPE = (VK_PHYSICAL_GPU_TYPE_END_RANGE - VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_PHYSICAL_GPU_TYPE) -} VK_PHYSICAL_GPU_TYPE; + VK_MAX_ENUM(VkPhysicalGpuType_) +} VkPhysicalGpuType; -typedef enum _VK_PHYSICAL_GPU_INFO_TYPE +typedef enum VkPhysicalGpuInfoType_ { // Info type for vkGetGpuInfo() VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES = 0x00000000, @@ -667,10 +667,10 @@ typedef enum _VK_PHYSICAL_GPU_INFO_TYPE VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, VK_NUM_INFO_TYPE_PHYSICAL_GPU = (VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE - VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_PHYSICAL_GPU_INFO_TYPE) -} VK_PHYSICAL_GPU_INFO_TYPE; + VK_MAX_ENUM(VkPhysicalGpuInfoType_) +} VkPhysicalGpuInfoType; -typedef enum _VK_FORMAT_INFO_TYPE +typedef enum VkFormatInfoType_ { // Info type for vkGetFormatInfo() VK_INFO_TYPE_FORMAT_PROPERTIES = 0x00000000, @@ -678,10 +678,10 @@ typedef enum _VK_FORMAT_INFO_TYPE VK_INFO_TYPE_FORMAT_BEGIN_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES, VK_INFO_TYPE_FORMAT_END_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES, VK_NUM_INFO_TYPE_FORMAT = (VK_INFO_TYPE_FORMAT_END_RANGE - VK_INFO_TYPE_FORMAT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_FORMAT_INFO_TYPE) -} VK_FORMAT_INFO_TYPE; + VK_MAX_ENUM(VkFormatInfoType_) +} VkFormatInfoType; -typedef enum _VK_SUBRESOURCE_INFO_TYPE +typedef enum VkSubresourceInfoType_ { // Info type for vkGetImageSubresourceInfo() VK_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000, @@ -689,10 +689,10 @@ typedef enum _VK_SUBRESOURCE_INFO_TYPE VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT, VK_INFO_TYPE_SUBRESOURCE_END_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT, VK_NUM_INFO_TYPE_SUBRESOURCE = (VK_INFO_TYPE_SUBRESOURCE_END_RANGE - VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_SUBRESOURCE_INFO_TYPE) -} VK_SUBRESOURCE_INFO_TYPE; + VK_MAX_ENUM(VkSubresourceInfoType_) +} VkSubresourceInfoType; -typedef enum _VK_OBJECT_INFO_TYPE +typedef enum VkObjectInfoType_ { // Info type for vkGetObjectInfo() VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000, @@ -703,10 +703,10 @@ typedef enum _VK_OBJECT_INFO_TYPE VK_INFO_TYPE_BEGIN_RANGE = VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, VK_INFO_TYPE_END_RANGE = VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, VK_NUM_INFO_TYPE = (VK_INFO_TYPE_END_RANGE - VK_INFO_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_OBJECT_INFO_TYPE) -} VK_OBJECT_INFO_TYPE; + VK_MAX_ENUM(VkObjectInfoType_) +} VkObjectInfoType; -typedef enum _VK_VALIDATION_LEVEL +typedef enum VkValidationLevel_ { VK_VALIDATION_LEVEL_0 = 0x00000000, VK_VALIDATION_LEVEL_1 = 0x00000001, @@ -718,13 +718,13 @@ typedef enum _VK_VALIDATION_LEVEL VK_VALIDATION_LEVEL_END_RANGE = VK_VALIDATION_LEVEL_4, VK_NUM_VALIDATION_LEVEL = (VK_VALIDATION_LEVEL_END_RANGE - VK_VALIDATION_LEVEL_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_VALIDATION_LEVEL) -} VK_VALIDATION_LEVEL; + VK_MAX_ENUM(VkValidationLevel_) +} VkValidationLevel; // ------------------------------------------------------------------------------------------------ // Error and return codes -typedef enum _VK_RESULT +typedef enum VkResult_ { // Return codes for successful operation execution (> = 0) VK_SUCCESS = 0x0000000, @@ -770,12 +770,12 @@ typedef enum _VK_RESULT VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021), VK_ERROR_NOT_SHAREABLE = -(0x00000022), VK_MAX_ENUM(_VK_RESULT_CODE) -} VK_RESULT; +} VkResult; // ------------------------------------------------------------------------------------------------ // Vulkan format definitions -typedef enum _VK_VERTEX_INPUT_STEP_RATE +typedef enum VkVertexInputStepRate_ { VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0, VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1, @@ -784,10 +784,10 @@ typedef enum _VK_VERTEX_INPUT_STEP_RATE VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_DRAW, VK_NUM_VERTEX_INPUT_STEP_RATE = (VK_VERTEX_INPUT_STEP_RATE_END_RANGE - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_VERTEX_INPUT_STEP_RATE) -} VK_VERTEX_INPUT_STEP_RATE; + VK_MAX_ENUM(VkVertexInputStepRate_) +} VkVertexInputStepRate; -typedef enum _VK_FORMAT +typedef enum VkFormat_ { VK_FMT_UNDEFINED = 0x00000000, VK_FMT_R4G4_UNORM = 0x00000001, @@ -967,11 +967,11 @@ typedef enum _VK_FORMAT VK_FMT_BEGIN_RANGE = VK_FMT_UNDEFINED, VK_FMT_END_RANGE = VK_FMT_B10G10R10A2_SINT, VK_NUM_FMT = (VK_FMT_END_RANGE - VK_FMT_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_FORMAT) -} VK_FORMAT; + VK_MAX_ENUM(VkFormat_) +} VkFormat; // Shader stage enumerant -typedef enum _VK_PIPELINE_SHADER_STAGE +typedef enum VkPipelineShaderStage_ { VK_SHADER_STAGE_VERTEX = 0, VK_SHADER_STAGE_TESS_CONTROL = 1, @@ -983,10 +983,10 @@ typedef enum _VK_PIPELINE_SHADER_STAGE VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, VK_NUM_SHADER_STAGE = (VK_SHADER_STAGE_END_RANGE - VK_SHADER_STAGE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_PIPELINE_SHADER_STAGE) -} VK_PIPELINE_SHADER_STAGE; + VK_MAX_ENUM(VkPipelineShaderStage_) +} VkPipelineShaderStage; -typedef enum _VK_SHADER_STAGE_FLAGS +typedef enum VkShaderStageFlags_ { VK_SHADER_STAGE_FLAGS_VERTEX_BIT = 0x00000001, VK_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT = 0x00000002, @@ -996,11 +996,11 @@ typedef enum _VK_SHADER_STAGE_FLAGS VK_SHADER_STAGE_FLAGS_COMPUTE_BIT = 0x00000020, VK_SHADER_STAGE_FLAGS_ALL = 0x7FFFFFFF, - VK_MAX_ENUM(_VK_SHADER_STAGE_FLAGS) -} VK_SHADER_STAGE_FLAGS; + VK_MAX_ENUM(VkShaderStageFlags_) +} VkShaderStageFlags; // Structure type enumerant -typedef enum _VK_STRUCTURE_TYPE +typedef enum VkStructureType_ { VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, @@ -1063,32 +1063,32 @@ typedef enum _VK_STRUCTURE_TYPE VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, VK_NUM_STRUCTURE_TYPE = (VK_STRUCTURE_TYPE_END_RANGE - VK_STRUCTURE_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_STRUCTURE_TYPE) -} VK_STRUCTURE_TYPE; + VK_MAX_ENUM(VkStructureType_) +} VkStructureType; // ------------------------------------------------------------------------------------------------ // Flags // Device creation flags -typedef enum _VK_DEVICE_CREATE_FLAGS +typedef enum VkDeviceCreateFlags_ { VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, VK_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002, - VK_MAX_ENUM(_VK_DEVICE_CREATE_FLAGS) -} VK_DEVICE_CREATE_FLAGS; + VK_MAX_ENUM(VkDeviceCreateFlags_) +} VkDeviceCreateFlags; // Queue capabilities -typedef enum _VK_QUEUE_FLAGS +typedef enum VkQueueFlags_ { VK_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations VK_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations VK_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations VK_QUEUE_EXTENDED_BIT = 0x40000000, // Extended queue - VK_MAX_ENUM(_VK_QUEUE_FLAGS) -} VK_QUEUE_FLAGS; + VK_MAX_ENUM(VkQueueFlags_) +} VkQueueFlags; // memory properties passed into vkAllocMemory(). -typedef enum _VK_MEMORY_PROPERTY_FLAGS +typedef enum VkMemoryPropertyFlags_ { VK_MEMORY_PROPERTY_GPU_ONLY = 0x00000000, // If not set, then allocate memory on device (GPU) VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT = 0x00000001, @@ -1097,10 +1097,10 @@ typedef enum _VK_MEMORY_PROPERTY_FLAGS VK_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT = 0x00000008, VK_MEMORY_PROPERTY_PREFER_CPU_LOCAL = 0x00000010, // all else being equal, prefer CPU access VK_MEMORY_PROPERTY_SHAREABLE_BIT = 0x00000020, - VK_MAX_ENUM(_VK_MEMORY_PROPERTY_FLAGS) -} VK_MEMORY_PROPERTY_FLAGS; + VK_MAX_ENUM(VkMemoryPropertyFlags_) +} VkMemoryPropertyFlags; -typedef enum _VK_MEMORY_TYPE +typedef enum VkMemoryType_ { VK_MEMORY_TYPE_OTHER = 0x00000000, // device memory that is not any of the others VK_MEMORY_TYPE_BUFFER = 0x00000001, // memory for buffers and associated information @@ -1109,11 +1109,11 @@ typedef enum _VK_MEMORY_TYPE VK_MEMORY_TYPE_BEGIN_RANGE = VK_MEMORY_TYPE_OTHER, VK_MEMORY_TYPE_END_RANGE = VK_MEMORY_TYPE_IMAGE, VK_NUM_MEMORY_TYPE = (VK_MEMORY_TYPE_END_RANGE - VK_MEMORY_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_MEMORY_TYPE) -} VK_MEMORY_TYPE; + VK_MAX_ENUM(VkMemoryType_) +} VkMemoryType; // Buffer and buffer allocation usage flags -typedef enum _VK_BUFFER_USAGE_FLAGS +typedef enum VkBufferUsageFlags_ { VK_BUFFER_USAGE_GENERAL = 0x00000000, // no special usage VK_BUFFER_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // Shader read (e.g. TBO, image buffer, UBO, SSBO) @@ -1128,18 +1128,18 @@ typedef enum _VK_BUFFER_USAGE_FLAGS VK_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT = 0x00000200, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) VK_BUFFER_USAGE_TEXTURE_BUFFER_BIT = 0x00000400, // texture buffer (TBO) VK_BUFFER_USAGE_IMAGE_BUFFER_BIT = 0x00000800, // image buffer (load/store) - VK_MAX_ENUM(_VK_BUFFER_USAGE_FLAGS) -} VK_BUFFER_USAGE_FLAGS; + VK_MAX_ENUM(VkBufferUsageFlags_) +} VkBufferUsageFlags; // Buffer flags -typedef enum _VK_BUFFER_CREATE_FLAGS +typedef enum VkBufferCreateFlags_ { VK_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001, VK_BUFFER_CREATE_SPARSE_BIT = 0x00000002, - VK_MAX_ENUM(_VK_BUFFER_CREATE_FLAGS) -} VK_BUFFER_CREATE_FLAGS; + VK_MAX_ENUM(VkBufferCreateFlags_) +} VkBufferCreateFlags; -typedef enum _VK_BUFFER_VIEW_TYPE +typedef enum VkBufferViewType_ { VK_BUFFER_VIEW_RAW = 0x00000000, // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers) VK_BUFFER_VIEW_TYPED = 0x00000001, // Typed buffer, format and channels are used (TBO, image buffer) @@ -1147,12 +1147,12 @@ typedef enum _VK_BUFFER_VIEW_TYPE VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_RAW, VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPED, VK_NUM_BUFFER_VIEW_TYPE = (VK_BUFFER_VIEW_TYPE_END_RANGE - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_BUFFER_VIEW_TYPE) -} VK_BUFFER_VIEW_TYPE; + VK_MAX_ENUM(VkBufferViewType_) +} VkBufferViewType; // Images memory allocations can be used for resources of a given format class. -typedef enum _VK_IMAGE_FORMAT_CLASS +typedef enum VkImageFormatClass_ { VK_IMAGE_FORMAT_CLASS_128_BITS = 1, // color formats VK_IMAGE_FORMAT_CLASS_96_BITS = 2, @@ -1176,11 +1176,11 @@ typedef enum _VK_IMAGE_FORMAT_CLASS VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE = VK_IMAGE_FORMAT_CLASS_128_BITS, VK_IMAGE_FORMAT_CLASS_END_RANGE = VK_IMAGE_FORMAT_CLASS_LINEAR, VK_NUM_IMAGE_FORMAT_CLASS = (VK_IMAGE_FORMAT_CLASS_END_RANGE - VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE + 1), - VK_MAX_ENUM(_VK_IMAGE_FORMAT_CLASS) -} VK_IMAGE_FORMAT_CLASS; + VK_MAX_ENUM(VkImageFormatClass_) +} VkImageFormatClass; // Image and image allocation usage flags -typedef enum _VK_IMAGE_USAGE_FLAGS +typedef enum VkImageUsageFlags_ { VK_IMAGE_USAGE_GENERAL = 0x00000000, // no special usage VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // shader read (e.g. texture, image) @@ -1193,52 +1193,52 @@ typedef enum _VK_IMAGE_USAGE_FLAGS VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000080, // framebuffer color attachment VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000100, // framebuffer depth/stencil VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000200, // image data not needed outside of rendering. - VK_MAX_ENUM(_VK_IMAGE_USAGE_FLAGS) -} VK_IMAGE_USAGE_FLAGS; + VK_MAX_ENUM(VkImageUsageFlags_) +} VkImageUsageFlags; // Image flags -typedef enum _VK_IMAGE_CREATE_FLAGS +typedef enum VkImageCreateFlags_ { VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001, VK_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002, VK_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004, VK_IMAGE_CREATE_SPARSE_BIT = 0x00000008, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, // Allows image views to have different format than the base image - VK_MAX_ENUM(_VK_IMAGE_CREATE_FLAGS) -} VK_IMAGE_CREATE_FLAGS; + VK_MAX_ENUM(VkImageCreateFlags_) +} VkImageCreateFlags; // Depth-stencil view creation flags -typedef enum _VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS +typedef enum VkDepthStencilViewCreateFlags_ { VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, - VK_MAX_ENUM(_VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS) -} VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS; + VK_MAX_ENUM(VkDepthStencilViewCreateFlags_) +} VkDepthStencilViewCreateFlags; // Pipeline creation flags -typedef enum _VK_PIPELINE_CREATE_FLAGS +typedef enum VkPipelineCreateFlags_ { VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_MAX_ENUM(_VK_PIPELINE_CREATE_FLAGS) -} VK_PIPELINE_CREATE_FLAGS; + VK_MAX_ENUM(VkPipelineCreateFlags_) +} VkPipelineCreateFlags; // Fence creation flags -typedef enum _VK_FENCE_CREATE_FLAGS +typedef enum VkFenceCreateFlags_ { VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, - VK_MAX_ENUM(_VK_FENCE_CREATE_FLAGS) -} VK_FENCE_CREATE_FLAGS; + VK_MAX_ENUM(VkFenceCreateFlags_) +} VkFenceCreateFlags; // Semaphore creation flags -typedef enum _VK_SEMAPHORE_CREATE_FLAGS +typedef enum VkSemaphoreCreateFlags_ { VK_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001, - VK_MAX_ENUM(_VK_SEMAPHORE_CREATE_FLAGS) -} VK_SEMAPHORE_CREATE_FLAGS; + VK_MAX_ENUM(VkSemaphoreCreateFlags_) +} VkSemaphoreCreateFlags; // Format capability flags -typedef enum _VK_FORMAT_FEATURE_FLAGS +typedef enum VkFormatFeatureFlags_ { VK_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001, VK_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002, @@ -1250,18 +1250,18 @@ typedef enum _VK_FORMAT_FEATURE_FLAGS VK_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080, VK_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100, VK_FORMAT_CONVERSION_BIT = 0x00000200, - VK_MAX_ENUM(_VK_FORMAT_FEATURE_FLAGS) -} VK_FORMAT_FEATURE_FLAGS; + VK_MAX_ENUM(VkFormatFeatureFlags_) +} VkFormatFeatureFlags; // Query flags -typedef enum _VK_QUERY_CONTROL_FLAGS +typedef enum VkQueryControlFlags_ { VK_QUERY_IMPRECISE_DATA_BIT = 0x00000001, - VK_MAX_ENUM(_VK_QUERY_CONTROL_FLAGS) -} VK_QUERY_CONTROL_FLAGS; + VK_MAX_ENUM(VkQueryControlFlags_) +} VkQueryControlFlags; // GPU compatibility flags -typedef enum _VK_GPU_COMPATIBILITY_FLAGS +typedef enum VkGpuCompatibilityFlags_ { VK_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001, VK_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002, @@ -1270,49 +1270,49 @@ typedef enum _VK_GPU_COMPATIBILITY_FLAGS VK_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010, VK_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020, VK_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040, - VK_MAX_ENUM(_VK_GPU_COMPATIBILITY_FLAGS) -} VK_GPU_COMPATIBILITY_FLAGS; + VK_MAX_ENUM(VkGpuCompatibilityFlags_) +} VkGpuCompatibilityFlags; // Command buffer building flags -typedef enum _VK_CMD_BUFFER_BUILD_FLAGS +typedef enum VkCmdBufferBuildFlags_ { VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001, VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, - VK_MAX_ENUM(_VK_CMD_BUFFER_BUILD_FLAGS) -} VK_CMD_BUFFER_BUILD_FLAGS; + VK_MAX_ENUM(VkCmdBufferBuildFlags_) +} VkCmdBufferBuildFlags; // ------------------------------------------------------------------------------------------------ // Vulkan structures -typedef struct _VK_OFFSET2D +typedef struct VkOffset2D_ { int32_t x; int32_t y; -} VK_OFFSET2D; +} VkOffset2D; -typedef struct _VK_OFFSET3D +typedef struct VkOffset3D_ { int32_t x; int32_t y; int32_t z; -} VK_OFFSET3D; +} VkOffset3D; -typedef struct _VK_EXTENT2D +typedef struct VkExtent2D_ { int32_t width; int32_t height; -} VK_EXTENT2D; +} VkExtent2D; -typedef struct _VK_EXTENT3D +typedef struct VkExtent3D_ { int32_t width; int32_t height; int32_t depth; -} VK_EXTENT3D; +} VkExtent3D; -typedef struct _VK_VIEWPORT +typedef struct VkViewport_ { float originX; float originY; @@ -1320,31 +1320,31 @@ typedef struct _VK_VIEWPORT float height; float minDepth; float maxDepth; -} VK_VIEWPORT; +} VkViewport; -typedef struct _VK_RECT +typedef struct VkRect_ { - VK_OFFSET2D offset; - VK_EXTENT2D extent; -} VK_RECT; + VkOffset2D offset; + VkExtent2D extent; +} VkRect; -typedef struct _VK_CHANNEL_MAPPING +typedef struct VkChannelMapping_ { - VK_CHANNEL_SWIZZLE r; - VK_CHANNEL_SWIZZLE g; - VK_CHANNEL_SWIZZLE b; - VK_CHANNEL_SWIZZLE a; -} VK_CHANNEL_MAPPING; + VkChannelSwizzle r; + VkChannelSwizzle g; + VkChannelSwizzle b; + VkChannelSwizzle a; +} VkChannelMapping; -typedef struct _VK_PHYSICAL_GPU_PROPERTIES +typedef struct VkPhysicalGpuProperties_ { uint32_t apiVersion; uint32_t driverVersion; uint32_t vendorId; uint32_t deviceId; - VK_PHYSICAL_GPU_TYPE gpuType; + VkPhysicalGpuType gpuType; char gpuName[VK_MAX_PHYSICAL_GPU_NAME]; - VK_GPU_SIZE maxInlineMemoryUpdateSize; + VkGpuSize maxInlineMemoryUpdateSize; uint32_t maxBoundDescriptorSets; uint32_t maxThreadGroupSize; uint64_t timestampFrequency; @@ -1352,49 +1352,49 @@ typedef struct _VK_PHYSICAL_GPU_PROPERTIES uint32_t maxDescriptorSets; // at least 2? uint32_t maxViewports; // at least 16? uint32_t maxColorAttachments; // at least 8? -} VK_PHYSICAL_GPU_PROPERTIES; +} VkPhysicalGpuProperties; -typedef struct _VK_PHYSICAL_GPU_PERFORMANCE +typedef struct VkPhysicalGpuPerformance_ { float maxGpuClock; float aluPerClock; float texPerClock; float primsPerClock; float pixelsPerClock; -} VK_PHYSICAL_GPU_PERFORMANCE; +} VkPhysicalGpuPerformance; -typedef struct _VK_GPU_COMPATIBILITY_INFO +typedef struct VkGpuCompatibilityInfo_ { - VK_FLAGS compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS -} VK_GPU_COMPATIBILITY_INFO; + VkFlags compatibilityFlags; // VkGpuCompatibilityFlags +} VkGpuCompatibilityInfo; -typedef struct _VK_APPLICATION_INFO +typedef struct VkApplicationInfo_ { - VK_STRUCTURE_TYPE sType; // Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO + VkStructureType sType; // Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO const void* pNext; // Next structure in chain const char* pAppName; uint32_t appVersion; const char* pEngineName; uint32_t engineVersion; uint32_t apiVersion; -} VK_APPLICATION_INFO; +} VkApplicationInfo; -typedef void* (VKAPI *VK_ALLOC_FUNCTION)( +typedef void* (VKAPI *PFN_vkAllocFunction)( void* pUserData, size_t size, size_t alignment, - VK_SYSTEM_ALLOC_TYPE allocType); + VkSystemAllocType allocType); -typedef void (VKAPI *VK_FREE_FUNCTION)( +typedef void (VKAPI *PFN_vkFreeFunction)( void* pUserData, void* pMem); -typedef struct _VK_ALLOC_CALLBACKS +typedef struct VkAllocCallbacks_ { void* pUserData; - VK_ALLOC_FUNCTION pfnAlloc; - VK_FREE_FUNCTION pfnFree; -} VK_ALLOC_CALLBACKS; + PFN_vkAllocFunction pfnAlloc; + PFN_vkFreeFunction pfnFree; +} VkAllocCallbacks; typedef struct _VkDeviceQueueCreateInfo { @@ -1404,22 +1404,22 @@ typedef struct _VkDeviceQueueCreateInfo typedef struct _VkDeviceCreateInfo { - VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO + VkStructureType sType; // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t queueRecordCount; const VkDeviceQueueCreateInfo* pRequestedQueues; uint32_t extensionCount; const char*const* ppEnabledExtensionNames; - VK_VALIDATION_LEVEL maxValidationLevel; - VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS + VkValidationLevel maxValidationLevel; + VkFlags flags; // VkDeviceCreateFlags } VkDeviceCreateInfo; typedef struct _VkInstanceCreateInfo { - VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO + VkStructureType sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO const void* pNext; // Pointer to next structure - const VK_APPLICATION_INFO* pAppInfo; - const VK_ALLOC_CALLBACKS* pAllocCb; + const VkApplicationInfo* pAppInfo; + const VkAllocCallbacks* pAllocCb; uint32_t extensionCount; const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled } VkInstanceCreateInfo; @@ -1427,656 +1427,656 @@ typedef struct _VkInstanceCreateInfo // can be added to VkDeviceCreateInfo or VkInstanceCreateInfo via pNext typedef struct _VkLayerCreateInfo { - VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO + VkStructureType sType; // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t layerCount; const char *const* ppActiveLayerNames; // layer name from the layer's vkEnumerateLayers()) } VkLayerCreateInfo; -typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES +typedef struct VkPhysicalGpuQueueProperties_ { - VK_FLAGS queueFlags; // VK_QUEUE_FLAGS + VkFlags queueFlags; // VkQueueFlags uint32_t queueCount; uint32_t maxAtomicCounters; bool32_t supportsTimestamps; uint32_t maxMemReferences; // Tells how many memory references can be active for the given queue -} VK_PHYSICAL_GPU_QUEUE_PROPERTIES; +} VkPhysicalGpuQueueProperties; -typedef struct _VK_PHYSICAL_GPU_MEMORY_PROPERTIES +typedef struct VkPhysicalGpuMemoryProperties_ { bool32_t supportsMigration; bool32_t supportsPinning; -} VK_PHYSICAL_GPU_MEMORY_PROPERTIES; +} VkPhysicalGpuMemoryProperties; typedef struct _VkMemoryAllocInfo { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO const void* pNext; // Pointer to next structure - VK_GPU_SIZE allocationSize; // Size of memory allocation - VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS - VK_MEMORY_TYPE memType; - VK_MEMORY_PRIORITY memPriority; + VkGpuSize allocationSize; // Size of memory allocation + VkFlags memProps; // VkMemoryPropertyFlags + VkMemoryType memType; + VkMemoryPriority memPriority; } VkMemoryAllocInfo; // This structure is included in the VkMemoryAllocInfo chain // for memory regions allocated for buffer usage. typedef struct _VkMemoryAllocBufferInfo { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS + VkFlags usage; // VkBufferUsageFlags } VkMemoryAllocBufferInfo; // This structure is included in the VkMemoryAllocInfo chain // for memory regions allocated for image usage. typedef struct _VkMemoryAllocImageInfo { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO const void* pNext; // Pointer to next structure - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; + VkFlags usage; // VkImageUsageFlags + VkImageFormatClass formatClass; uint32_t samples; } VkMemoryAllocImageInfo; -typedef struct _VK_MEMORY_OPEN_INFO +typedef struct VkMemoryOpenInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO const void* pNext; // Pointer to next structure - VK_GPU_MEMORY sharedMem; -} VK_MEMORY_OPEN_INFO; + VkGpuMemory sharedMem; +} VkMemoryOpenInfo; -typedef struct _VK_PEER_MEMORY_OPEN_INFO +typedef struct VkPeerMemoryOpenInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO const void* pNext; // Pointer to next structure - VK_GPU_MEMORY originalMem; -} VK_PEER_MEMORY_OPEN_INFO; + VkGpuMemory originalMem; +} VkPeerMemoryOpenInfo; -typedef struct _VK_MEMORY_REQUIREMENTS +typedef struct VkMemoryRequirements_ { - VK_GPU_SIZE size; // Specified in bytes - VK_GPU_SIZE alignment; // Specified in bytes - VK_GPU_SIZE granularity; // Granularity on which vkBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) - VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS - VK_MEMORY_TYPE memType; -} VK_MEMORY_REQUIREMENTS; + VkGpuSize size; // Specified in bytes + VkGpuSize alignment; // Specified in bytes + VkGpuSize granularity; // Granularity on which vkBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size) + VkFlags memProps; // VkMemoryPropertyFlags + VkMemoryType memType; +} VkMemoryRequirements; -typedef struct _VK_BUFFER_MEMORY_REQUIREMENTS +typedef struct VkBufferMemoryRequirements_ { - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS -} VK_BUFFER_MEMORY_REQUIREMENTS; + VkFlags usage; // VkBufferUsageFlags +} VkBufferMemoryRequirements; -typedef struct _VK_IMAGE_MEMORY_REQUIREMENTS +typedef struct VkImageMemoryRequirements_ { - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_IMAGE_FORMAT_CLASS formatClass; + VkFlags usage; // VkImageUsageFlags + VkImageFormatClass formatClass; uint32_t samples; -} VK_IMAGE_MEMORY_REQUIREMENTS; +} VkImageMemoryRequirements; -typedef struct _VK_FORMAT_PROPERTIES +typedef struct VkFormatProperties_ { - VK_FLAGS linearTilingFeatures; // VK_FORMAT_FEATURE_FLAGS - VK_FLAGS optimalTilingFeatures; // VK_FORMAT_FEATURE_FLAGS -} VK_FORMAT_PROPERTIES; + VkFlags linearTilingFeatures; // VkFormatFeatureFlags + VkFlags optimalTilingFeatures; // VkFormatFeatureFlags +} VkFormatProperties; -typedef struct _VK_BUFFER_VIEW_ATTACH_INFO +typedef struct VkBufferViewAttachInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO const void* pNext; // Pointer to next structure - VK_BUFFER_VIEW view; -} VK_BUFFER_VIEW_ATTACH_INFO; + VkBufferView view; +} VkBufferViewAttachInfo; -typedef struct _VK_IMAGE_VIEW_ATTACH_INFO +typedef struct VkImageViewAttachInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO const void* pNext; // Pointer to next structure - VK_IMAGE_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_IMAGE_VIEW_ATTACH_INFO; + VkImageView view; + VkImageLayout layout; +} VkImageViewAttachInfo; -typedef struct _VK_UPDATE_SAMPLERS +typedef struct VkUpdateSamplers_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLERS + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLERS const void* pNext; // Pointer to next structure uint32_t binding; // Binding of the sampler (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const VK_SAMPLER* pSamplers; -} VK_UPDATE_SAMPLERS; + const VkSampler* pSamplers; +} VkUpdateSamplers; -typedef struct _VK_SAMPLER_IMAGE_VIEW_INFO +typedef struct VkSamplerImageViewInfo_ { - VK_SAMPLER sampler; - const VK_IMAGE_VIEW_ATTACH_INFO* pImageView; -} VK_SAMPLER_IMAGE_VIEW_INFO; + VkSampler sampler; + const VkImageViewAttachInfo* pImageView; +} VkSamplerImageViewInfo; -typedef struct _VK_UPDATE_SAMPLER_TEXTURES +typedef struct VkUpdateSamplerTextures_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES const void* pNext; // Pointer to next structure uint32_t binding; // Binding of the combined texture sampler (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const VK_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews; -} VK_UPDATE_SAMPLER_TEXTURES; + const VkSamplerImageViewInfo* pSamplerImageViews; +} VkUpdateSamplerTextures; -typedef struct _VK_UPDATE_IMAGES +typedef struct VkUpdateImages_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES const void* pNext; // Pointer to next structure - VK_DESCRIPTOR_TYPE descriptorType; + VkDescriptorType descriptorType; uint32_t binding; // Binding of the image (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const VK_IMAGE_VIEW_ATTACH_INFO* pImageViews; -} VK_UPDATE_IMAGES; + const VkImageViewAttachInfo* pImageViews; +} VkUpdateImages; -typedef struct _VK_UPDATE_BUFFERS +typedef struct VkUpdateBuffers_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS const void* pNext; // Pointer to next structure - VK_DESCRIPTOR_TYPE descriptorType; + VkDescriptorType descriptorType; uint32_t binding; // Binding of the buffer (array) uint32_t arrayIndex; // First element of the array to update or zero otherwise uint32_t count; // Number of elements to update - const VK_BUFFER_VIEW_ATTACH_INFO* pBufferViews; -} VK_UPDATE_BUFFERS; + const VkBufferViewAttachInfo* pBufferViews; +} VkUpdateBuffers; -typedef struct _VK_UPDATE_AS_COPY +typedef struct VkUpdateAsCopy_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY const void* pNext; // Pointer to next structure - VK_DESCRIPTOR_TYPE descriptorType; - VK_DESCRIPTOR_SET descriptorSet; + VkDescriptorType descriptorType; + VkDescriptorSet descriptorSet; uint32_t binding; uint32_t arrayElement; uint32_t count; -} VK_UPDATE_AS_COPY; +} VkUpdateAsCopy; typedef struct _VkBufferCreateInfo { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO const void* pNext; // Pointer to next structure. - VK_GPU_SIZE size; // Specified in bytes - VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS - VK_FLAGS flags; // VK_BUFFER_CREATE_FLAGS + VkGpuSize size; // Specified in bytes + VkFlags usage; // VkBufferUsageFlags + VkFlags flags; // VkBufferCreateFlags } VkBufferCreateInfo; typedef struct _VkBufferViewCreateInfo { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure. - VK_BUFFER buffer; - VK_BUFFER_VIEW_TYPE viewType; - VK_FORMAT format; // Optionally specifies format of elements - VK_GPU_SIZE offset; // Specified in bytes - VK_GPU_SIZE range; // View size specified in bytes + VkBuffer buffer; + VkBufferViewType viewType; + VkFormat format; // Optionally specifies format of elements + VkGpuSize offset; // Specified in bytes + VkGpuSize range; // View size specified in bytes } VkBufferViewCreateInfo; -typedef struct _VK_IMAGE_SUBRESOURCE +typedef struct VkImageSubresource_ { - VK_IMAGE_ASPECT aspect; + VkImageAspect aspect; uint32_t mipLevel; uint32_t arraySlice; -} VK_IMAGE_SUBRESOURCE; +} VkImageSubresource; -typedef struct _VK_IMAGE_SUBRESOURCE_RANGE +typedef struct VkImageSubresourceRange_ { - VK_IMAGE_ASPECT aspect; + VkImageAspect aspect; uint32_t baseMipLevel; uint32_t mipLevels; uint32_t baseArraySlice; uint32_t arraySize; -} VK_IMAGE_SUBRESOURCE_RANGE; +} VkImageSubresourceRange; -typedef struct _VK_EVENT_WAIT_INFO +typedef struct VkEventWaitInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_WAIT_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_EVENT_WAIT_INFO const void* pNext; // Pointer to next structure. uint32_t eventCount; // Number of events to wait on - const VK_EVENT* pEvents; // Array of event objects to wait on + const VkEvent* pEvents; // Array of event objects to wait on - VK_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen + VkWaitEvent waitEvent; // Pipeline event where the wait should happen uint32_t memBarrierCount; // Number of memory barriers - const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) -} VK_EVENT_WAIT_INFO; + const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VkMemoryBarrier, VkBufferMemoryBarrier, or VkImageMemoryBarrier) +} VkEventWaitInfo; -typedef struct _VK_PIPELINE_BARRIER +typedef struct VkPipelineBarrier_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_BARRIER + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_BARRIER const void* pNext; // Pointer to next structure. uint32_t eventCount; // Number of events to wait on - const VK_PIPE_EVENT* pEvents; // Array of pipeline events to wait on + const VkPipeEvent* pEvents; // Array of pipeline events to wait on - VK_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen + VkWaitEvent waitEvent; // Pipeline event where the wait should happen uint32_t memBarrierCount; // Number of memory barriers - const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER) -} VK_PIPELINE_BARRIER; + const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VkMemoryBarrier, VkBufferMemoryBarrier, or VkImageMemoryBarrier) +} VkPipelineBarrier; -typedef struct _VK_MEMORY_BARRIER +typedef struct VkMemoryBarrier_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS) - VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS) -} VK_MEMORY_BARRIER; + VkFlags outputMask; // Outputs the barrier should sync (see VkMemoryOutputFlags) + VkFlags inputMask; // Inputs the barrier should sync to (see VkMemoryInputFlags) +} VkMemoryBarrier; -typedef struct _VK_BUFFER_MEMORY_BARRIER +typedef struct VkBufferMemoryBarrier_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS) - VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS) + VkFlags outputMask; // Outputs the barrier should sync (see VkMemoryOutputFlags) + VkFlags inputMask; // Inputs the barrier should sync to (see VkMemoryInputFlags) - VK_BUFFER buffer; // Buffer to sync + VkBuffer buffer; // Buffer to sync - VK_GPU_SIZE offset; // Offset within the buffer to sync - VK_GPU_SIZE size; // Amount of bytes to sync -} VK_BUFFER_MEMORY_BARRIER; + VkGpuSize offset; // Offset within the buffer to sync + VkGpuSize size; // Amount of bytes to sync +} VkBufferMemoryBarrier; -typedef struct _VK_IMAGE_MEMORY_BARRIER +typedef struct VkImageMemoryBarrier_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER const void* pNext; // Pointer to next structure. - VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS) - VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS) + VkFlags outputMask; // Outputs the barrier should sync (see VkMemoryOutputFlags) + VkFlags inputMask; // Inputs the barrier should sync to (see VkMemoryInputFlags) - VK_IMAGE_LAYOUT oldLayout; // Current layout of the image - VK_IMAGE_LAYOUT newLayout; // New layout to transition the image to + VkImageLayout oldLayout; // Current layout of the image + VkImageLayout newLayout; // New layout to transition the image to - VK_IMAGE image; // Image to sync + VkImage image; // Image to sync - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync -} VK_IMAGE_MEMORY_BARRIER; + VkImageSubresourceRange subresourceRange; // Subresource range to sync +} VkImageMemoryBarrier; -typedef struct _VK_IMAGE_CREATE_INFO +typedef struct VkImageCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO const void* pNext; // Pointer to next structure. - VK_IMAGE_TYPE imageType; - VK_FORMAT format; - VK_EXTENT3D extent; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; uint32_t mipLevels; uint32_t arraySize; uint32_t samples; - VK_IMAGE_TILING tiling; - VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS - VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS -} VK_IMAGE_CREATE_INFO; + VkImageTiling tiling; + VkFlags usage; // VkImageUsageFlags + VkFlags flags; // VkImageCreateFlags +} VkImageCreateInfo; -typedef struct _VK_PEER_IMAGE_OPEN_INFO +typedef struct VkPeerImageOpenInfo_ { - VK_IMAGE originalImage; -} VK_PEER_IMAGE_OPEN_INFO; + VkImage originalImage; +} VkPeerImageOpenInfo; -typedef struct _VK_SUBRESOURCE_LAYOUT +typedef struct VkSubresourceLayout_ { - VK_GPU_SIZE offset; // Specified in bytes - VK_GPU_SIZE size; // Specified in bytes - VK_GPU_SIZE rowPitch; // Specified in bytes - VK_GPU_SIZE depthPitch; // Specified in bytes -} VK_SUBRESOURCE_LAYOUT; + VkGpuSize offset; // Specified in bytes + VkGpuSize size; // Specified in bytes + VkGpuSize rowPitch; // Specified in bytes + VkGpuSize depthPitch; // Specified in bytes +} VkSubresourceLayout; -typedef struct _VK_IMAGE_VIEW_CREATE_INFO +typedef struct VkImageViewCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure - VK_IMAGE image; - VK_IMAGE_VIEW_TYPE viewType; - VK_FORMAT format; - VK_CHANNEL_MAPPING channels; - VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkChannelMapping channels; + VkImageSubresourceRange subresourceRange; float minLod; -} VK_IMAGE_VIEW_CREATE_INFO; +} VkImageViewCreateInfo; -typedef struct _VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO +typedef struct VkColorAttachmentViewCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure - VK_IMAGE image; - VK_FORMAT format; + VkImage image; + VkFormat format; uint32_t mipLevel; uint32_t baseArraySlice; uint32_t arraySize; - VK_IMAGE msaaResolveImage; - VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; -} VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO; + VkImage msaaResolveImage; + VkImageSubresourceRange msaaResolveSubResource; +} VkColorAttachmentViewCreateInfo; -typedef struct _VK_DEPTH_STENCIL_VIEW_CREATE_INFO +typedef struct VkDepthStencilViewCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO const void* pNext; // Pointer to next structure - VK_IMAGE image; + VkImage image; uint32_t mipLevel; uint32_t baseArraySlice; uint32_t arraySize; - VK_IMAGE msaaResolveImage; - VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource; - VK_FLAGS flags; // VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS -} VK_DEPTH_STENCIL_VIEW_CREATE_INFO; + VkImage msaaResolveImage; + VkImageSubresourceRange msaaResolveSubResource; + VkFlags flags; // VkDepthStencilViewCreateFlags +} VkDepthStencilViewCreateInfo; -typedef struct _VK_COLOR_ATTACHMENT_BIND_INFO +typedef struct VkColorAttachmentBindInfo_ { - VK_COLOR_ATTACHMENT_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_COLOR_ATTACHMENT_BIND_INFO; + VkColorAttachmentView view; + VkImageLayout layout; +} VkColorAttachmentBindInfo; -typedef struct _VK_DEPTH_STENCIL_BIND_INFO +typedef struct VkDepthStencilBindInfo_ { - VK_DEPTH_STENCIL_VIEW view; - VK_IMAGE_LAYOUT layout; -} VK_DEPTH_STENCIL_BIND_INFO; + VkDepthStencilView view; + VkImageLayout layout; +} VkDepthStencilBindInfo; -typedef struct _VK_BUFFER_COPY +typedef struct VkBufferCopy_ { - VK_GPU_SIZE srcOffset; // Specified in bytes - VK_GPU_SIZE destOffset; // Specified in bytes - VK_GPU_SIZE copySize; // Specified in bytes -} VK_BUFFER_COPY; + VkGpuSize srcOffset; // Specified in bytes + VkGpuSize destOffset; // Specified in bytes + VkGpuSize copySize; // Specified in bytes +} VkBufferCopy; -typedef struct _VK_IMAGE_MEMORY_BIND_INFO +typedef struct VkImageMemoryBindInfo_ { - VK_IMAGE_SUBRESOURCE subresource; - VK_OFFSET3D offset; - VK_EXTENT3D extent; -} VK_IMAGE_MEMORY_BIND_INFO; + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; +} VkImageMemoryBindInfo; -typedef struct _VK_IMAGE_COPY +typedef struct VkImageCopy_ { - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET3D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET3D destOffset; - VK_EXTENT3D extent; -} VK_IMAGE_COPY; + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D extent; +} VkImageCopy; -typedef struct _VK_IMAGE_BLIT +typedef struct VkImageBlit_ { - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET3D srcOffset; - VK_EXTENT3D srcExtent; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET3D destOffset; - VK_EXTENT3D destExtent; -} VK_IMAGE_BLIT; + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkExtent3D srcExtent; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D destExtent; +} VkImageBlit; -typedef struct _VK_BUFFER_IMAGE_COPY +typedef struct VkBufferImageCopy_ { - VK_GPU_SIZE bufferOffset; // Specified in bytes - VK_IMAGE_SUBRESOURCE imageSubresource; - VK_OFFSET3D imageOffset; - VK_EXTENT3D imageExtent; -} VK_BUFFER_IMAGE_COPY; + VkGpuSize bufferOffset; // Specified in bytes + VkImageSubresource imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; -typedef struct _VK_IMAGE_RESOLVE +typedef struct VkImageResolve_ { - VK_IMAGE_SUBRESOURCE srcSubresource; - VK_OFFSET2D srcOffset; - VK_IMAGE_SUBRESOURCE destSubresource; - VK_OFFSET2D destOffset; - VK_EXTENT2D extent; -} VK_IMAGE_RESOLVE; + VkImageSubresource srcSubresource; + VkOffset2D srcOffset; + VkImageSubresource destSubresource; + VkOffset2D destOffset; + VkExtent2D extent; +} VkImageResolve; -typedef struct _VK_SHADER_CREATE_INFO +typedef struct VkShaderCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO const void* pNext; // Pointer to next structure size_t codeSize; // Specified in bytes const void* pCode; - VK_FLAGS flags; // Reserved -} VK_SHADER_CREATE_INFO; + VkFlags flags; // Reserved +} VkShaderCreateInfo; -typedef struct _VK_DESCRIPTOR_SET_LAYOUT_BINDING +typedef struct VkDescriptorSetLayoutBinding_ { - VK_DESCRIPTOR_TYPE descriptorType; + VkDescriptorType descriptorType; uint32_t count; - VK_FLAGS stageFlags; // VK_SHADER_STAGE_FLAGS - const VK_SAMPLER* pImmutableSamplers; -} VK_DESCRIPTOR_SET_LAYOUT_BINDING; + VkFlags stageFlags; // VkShaderStageFlags + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; -typedef struct _VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO +typedef struct VkDescriptorSetLayoutCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t count; // Number of bindings in the descriptor set layout - const VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings -} VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + const VkDescriptorSetLayoutBinding* pBinding; // Array of descriptor set layout bindings +} VkDescriptorSetLayoutCreateInfo; -typedef struct _VK_DESCRIPTOR_TYPE_COUNT +typedef struct VkDescriptorTypeCount_ { - VK_DESCRIPTOR_TYPE type; + VkDescriptorType type; uint32_t count; -} VK_DESCRIPTOR_TYPE_COUNT; +} VkDescriptorTypeCount; -typedef struct _VK_DESCRIPTOR_POOL_CREATE_INFO +typedef struct VkDescriptorPoolCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t count; - const VK_DESCRIPTOR_TYPE_COUNT* pTypeCount; -} VK_DESCRIPTOR_POOL_CREATE_INFO; + const VkDescriptorTypeCount* pTypeCount; +} VkDescriptorPoolCreateInfo; -typedef struct _VK_LINK_CONST_BUFFER +typedef struct VkLinkConstBuffer_ { uint32_t bufferId; size_t bufferSize; const void* pBufferData; -} VK_LINK_CONST_BUFFER; +} VkLinkConstBuffer; -typedef struct _VK_SPECIALIZATION_MAP_ENTRY +typedef struct VkSpecializationMapEntry_ { uint32_t constantId; // The SpecConstant ID specified in the BIL uint32_t offset; // Offset of the value in the data block -} VK_SPECIALIZATION_MAP_ENTRY; +} VkSpecializationMapEntry; -typedef struct _VK_SPECIALIZATION_INFO +typedef struct VkSpecializationInfo_ { uint32_t mapEntryCount; - const VK_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries + const VkSpecializationMapEntry* pMap; // mapEntryCount entries const void* pData; -} VK_SPECIALIZATION_INFO; +} VkSpecializationInfo; -typedef struct _VK_PIPELINE_SHADER +typedef struct VkPipelineShader_ { - VK_PIPELINE_SHADER_STAGE stage; - VK_SHADER shader; + VkPipelineShaderStage stage; + VkShader shader; uint32_t linkConstBufferCount; - const VK_LINK_CONST_BUFFER* pLinkConstBufferInfo; - const VK_SPECIALIZATION_INFO* pSpecializationInfo; -} VK_PIPELINE_SHADER; + const VkLinkConstBuffer* pLinkConstBufferInfo; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShader; -typedef struct _VK_COMPUTE_PIPELINE_CREATE_INFO +typedef struct VkComputePipelineCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO const void* pNext; // Pointer to next structure - VK_PIPELINE_SHADER cs; - VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS - VK_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; + VkPipelineShader cs; + VkFlags flags; // VkPipelineCreateFlags + VkDescriptorSetLayoutChain setLayoutChain; uint32_t localSizeX; uint32_t localSizeY; uint32_t localSizeZ; -} VK_COMPUTE_PIPELINE_CREATE_INFO; +} VkComputePipelineCreateInfo; -typedef struct _VK_VERTEX_INPUT_BINDING_DESCRIPTION +typedef struct VkVertexInputBindingDescription_ { uint32_t binding; // Vertex buffer binding id uint32_t strideInBytes; // Distance between vertices in bytes (0 = no advancement) - VK_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented -} VK_VERTEX_INPUT_BINDING_DESCRIPTION; + VkVertexInputStepRate stepRate; // Rate at which binding is incremented +} VkVertexInputBindingDescription; -typedef struct _VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION +typedef struct VkVertexInputAttributeDescription_ { uint32_t location; // location of the shader vertex attrib uint32_t binding; // Vertex buffer binding id - VK_FORMAT format; // format of source data + VkFormat format; // format of source data uint32_t offsetInBytes; // Offset of first element in bytes from base of vertex -} VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION; +} VkVertexInputAttributeDescription; -typedef struct _VK_PIPELINE_VERTEX_INPUT_CREATE_INFO +typedef struct VkPipelineVertexInputCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO + VkStructureType sType; // Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t bindingCount; // number of bindings - const VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; uint32_t attributeCount; // number of attributes - const VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; -} VK_PIPELINE_VERTEX_INPUT_CREATE_INFO; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputCreateInfo; -typedef struct _VK_PIPELINE_IA_STATE_CREATE_INFO +typedef struct VkPipelineIaStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO const void* pNext; // Pointer to next structure - VK_PRIMITIVE_TOPOLOGY topology; + VkPrimitiveTopology topology; bool32_t disableVertexReuse; // optional bool32_t primitiveRestartEnable; uint32_t primitiveRestartIndex; // optional (GL45) -} VK_PIPELINE_IA_STATE_CREATE_INFO; +} VkPipelineIaStateCreateInfo; -typedef struct _VK_PIPELINE_TESS_STATE_CREATE_INFO +typedef struct VkPipelineTessStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t patchControlPoints; -} VK_PIPELINE_TESS_STATE_CREATE_INFO; +} VkPipelineTessStateCreateInfo; -typedef struct _VK_PIPELINE_VP_STATE_CREATE_INFO +typedef struct VkPipelineVpStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t numViewports; - VK_COORDINATE_ORIGIN clipOrigin; // optional (GL45) - VK_DEPTH_MODE depthMode; // optional (GL45) -} VK_PIPELINE_VP_STATE_CREATE_INFO; + VkCoordinateOrigin clipOrigin; // optional (GL45) + VkDepthMode depthMode; // optional (GL45) +} VkPipelineVpStateCreateInfo; -typedef struct _VK_PIPELINE_RS_STATE_CREATE_INFO +typedef struct VkPipelineRsStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure bool32_t depthClipEnable; bool32_t rasterizerDiscardEnable; bool32_t programPointSize; // optional (GL45) - VK_COORDINATE_ORIGIN pointOrigin; // optional (GL45) - VK_PROVOKING_VERTEX_CONVENTION provokingVertex; // optional (GL45) - VK_FILL_MODE fillMode; // optional (GL45) - VK_CULL_MODE cullMode; - VK_FACE_ORIENTATION frontFace; -} VK_PIPELINE_RS_STATE_CREATE_INFO; + VkCoordinateOrigin pointOrigin; // optional (GL45) + VkProvokingVertexConvention provokingVertex; // optional (GL45) + VkFillMode fillMode; // optional (GL45) + VkCullMode cullMode; + VkFaceOrientation frontFace; +} VkPipelineRsStateCreateInfo; -typedef struct _VK_PIPELINE_MS_STATE_CREATE_INFO +typedef struct VkPipelineMsStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t samples; bool32_t multisampleEnable; // optional (GL45) bool32_t sampleShadingEnable; // optional (GL45) float minSampleShading; // optional (GL45) - VK_SAMPLE_MASK sampleMask; -} VK_PIPELINE_MS_STATE_CREATE_INFO; + VkSampleMask sampleMask; +} VkPipelineMsStateCreateInfo; -typedef struct _VK_PIPELINE_CB_ATTACHMENT_STATE +typedef struct VkPipelineCbAttachmentState_ { bool32_t blendEnable; - VK_FORMAT format; - VK_BLEND srcBlendColor; - VK_BLEND destBlendColor; - VK_BLEND_FUNC blendFuncColor; - VK_BLEND srcBlendAlpha; - VK_BLEND destBlendAlpha; - VK_BLEND_FUNC blendFuncAlpha; + VkFormat format; + VkBlend srcBlendColor; + VkBlend destBlendColor; + VkBlendFunc blendFuncColor; + VkBlend srcBlendAlpha; + VkBlend destBlendAlpha; + VkBlendFunc blendFuncAlpha; uint8_t channelWriteMask; -} VK_PIPELINE_CB_ATTACHMENT_STATE; +} VkPipelineCbAttachmentState; -typedef struct _VK_PIPELINE_CB_STATE_CREATE_INFO +typedef struct VkPipelineCbStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO const void* pNext; // Pointer to next structure bool32_t alphaToCoverageEnable; bool32_t logicOpEnable; - VK_LOGIC_OP logicOp; + VkLogicOp logicOp; uint32_t attachmentCount; // # of pAttachments - const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; -} VK_PIPELINE_CB_STATE_CREATE_INFO; + const VkPipelineCbAttachmentState* pAttachments; +} VkPipelineCbStateCreateInfo; -typedef struct _VK_STENCIL_OP_STATE +typedef struct VkStencilOpState_ { - VK_STENCIL_OP stencilFailOp; - VK_STENCIL_OP stencilPassOp; - VK_STENCIL_OP stencilDepthFailOp; - VK_COMPARE_FUNC stencilFunc; -} VK_STENCIL_OP_STATE; + VkStencilOp stencilFailOp; + VkStencilOp stencilPassOp; + VkStencilOp stencilDepthFailOp; + VkCompareFunc stencilFunc; +} VkStencilOpState; -typedef struct _VK_PIPELINE_DS_STATE_CREATE_INFO +typedef struct VkPipelineDsStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure - VK_FORMAT format; + VkFormat format; bool32_t depthTestEnable; bool32_t depthWriteEnable; - VK_COMPARE_FUNC depthFunc; + VkCompareFunc depthFunc; bool32_t depthBoundsEnable; // optional (depth_bounds_test) bool32_t stencilTestEnable; - VK_STENCIL_OP_STATE front; - VK_STENCIL_OP_STATE back; -} VK_PIPELINE_DS_STATE_CREATE_INFO; + VkStencilOpState front; + VkStencilOpState back; +} VkPipelineDsStateCreateInfo; -typedef struct _VK_PIPELINE_SHADER_STAGE_CREATE_INFO +typedef struct VkPipelineShaderStageCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO const void* pNext; // Pointer to next structure - VK_PIPELINE_SHADER shader; -} VK_PIPELINE_SHADER_STAGE_CREATE_INFO; + VkPipelineShader shader; +} VkPipelineShaderStageCreateInfo; -typedef struct _VK_GRAPHICS_PIPELINE_CREATE_INFO +typedef struct VkGraphicsPipelineCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO const void* pNext; // Pointer to next structure - VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS - VK_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain; -} VK_GRAPHICS_PIPELINE_CREATE_INFO; + VkFlags flags; // VkPipelineCreateFlags + VkDescriptorSetLayoutChain pSetLayoutChain; +} VkGraphicsPipelineCreateInfo; -typedef struct _VK_SAMPLER_CREATE_INFO +typedef struct VkSamplerCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO const void* pNext; // Pointer to next structure - VK_TEX_FILTER magFilter; // Filter mode for magnification - VK_TEX_FILTER minFilter; // Filter mode for minifiation - VK_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode - VK_TEX_ADDRESS addressU; - VK_TEX_ADDRESS addressV; - VK_TEX_ADDRESS addressW; + VkTexFilter magFilter; // Filter mode for magnification + VkTexFilter minFilter; // Filter mode for minifiation + VkTexMipmapMode mipMode; // Mipmap selection mode + VkTexAddress addressU; + VkTexAddress addressV; + VkTexAddress addressW; float mipLodBias; uint32_t maxAnisotropy; - VK_COMPARE_FUNC compareFunc; + VkCompareFunc compareFunc; float minLod; float maxLod; - VK_BORDER_COLOR_TYPE borderColorType; -} VK_SAMPLER_CREATE_INFO; + VkBorderColorType borderColorType; +} VkSamplerCreateInfo; -typedef struct _VK_DYNAMIC_VP_STATE_CREATE_INFO +typedef struct VkDynamicVpStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t viewportAndScissorCount; // number of entries in pViewports and pScissors - const VK_VIEWPORT* pViewports; - const VK_RECT* pScissors; -} VK_DYNAMIC_VP_STATE_CREATE_INFO; + const VkViewport* pViewports; + const VkRect* pScissors; +} VkDynamicVpStateCreateInfo; -typedef struct _VK_DYNAMIC_RS_STATE_CREATE_INFO +typedef struct VkDynamicRsStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure float depthBias; float depthBiasClamp; @@ -2084,18 +2084,18 @@ typedef struct _VK_DYNAMIC_RS_STATE_CREATE_INFO float pointSize; // optional (GL45) - Size of points float pointFadeThreshold; // optional (GL45) - Size of point fade threshold float lineWidth; // optional (GL45) - Width of lines -} VK_DYNAMIC_RS_STATE_CREATE_INFO; +} VkDynamicRsStateCreateInfo; -typedef struct _VK_DYNAMIC_CB_STATE_CREATE_INFO +typedef struct VkDynamicCbStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO const void* pNext; // Pointer to next structure float blendConst[4]; -} VK_DYNAMIC_CB_STATE_CREATE_INFO; +} VkDynamicCbStateCreateInfo; -typedef struct _VK_DYNAMIC_DS_STATE_CREATE_INFO +typedef struct VkDynamicDsStateCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO const void* pNext; // Pointer to next structure float minDepth; // optional (depth_bounds_test) float maxDepth; // optional (depth_bounds_test) @@ -2103,106 +2103,106 @@ typedef struct _VK_DYNAMIC_DS_STATE_CREATE_INFO uint32_t stencilWriteMask; uint32_t stencilFrontRef; uint32_t stencilBackRef; -} VK_DYNAMIC_DS_STATE_CREATE_INFO; +} VkDynamicDsStateCreateInfo; -typedef struct _VK_CMD_BUFFER_CREATE_INFO +typedef struct VkCmdBufferCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t queueNodeIndex; - VK_FLAGS flags; -} VK_CMD_BUFFER_CREATE_INFO; + VkFlags flags; +} VkCmdBufferCreateInfo; -typedef struct _VK_CMD_BUFFER_BEGIN_INFO +typedef struct VkCmdBufferBeginInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO const void* pNext; // Pointer to next structure - VK_FLAGS flags; // VK_CMD_BUFFER_BUILD_FLAGS -} VK_CMD_BUFFER_BEGIN_INFO; + VkFlags flags; // VkCmdBufferBuildFlags +} VkCmdBufferBeginInfo; -typedef struct _VK_RENDER_PASS_BEGIN +typedef struct VkRenderPassBegin_ { - VK_RENDER_PASS renderPass; - VK_FRAMEBUFFER framebuffer; -} VK_RENDER_PASS_BEGIN; + VkRenderPass renderPass; + VkFramebuffer framebuffer; +} VkRenderPassBegin; -typedef struct _VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO +typedef struct VkCmdBufferGraphicsBeginInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO const void* pNext; // Pointer to next structure - VK_RENDER_PASS_BEGIN renderPassContinue; // Only needed when a render pass is split across two command buffers -} VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO; + VkRenderPassBegin renderPassContinue; // Only needed when a render pass is split across two command buffers +} VkCmdBufferGraphicsBeginInfo; // Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared. -typedef union _VK_CLEAR_COLOR_VALUE +typedef union VkClearColorValue_ { float floatColor[4]; uint32_t rawColor[4]; -} VK_CLEAR_COLOR_VALUE; +} VkClearColorValue; -typedef struct _VK_CLEAR_COLOR +typedef struct VkClearColor_ { - VK_CLEAR_COLOR_VALUE color; + VkClearColorValue color; bool32_t useRawValue; -} VK_CLEAR_COLOR; +} VkClearColor; -typedef struct _VK_RENDER_PASS_CREATE_INFO +typedef struct VkRenderPassCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO const void* pNext; // Pointer to next structure - VK_RECT renderArea; + VkRect renderArea; uint32_t colorAttachmentCount; - VK_EXTENT2D extent; + VkExtent2D extent; uint32_t sampleCount; uint32_t layers; - const VK_FORMAT* pColorFormats; - const VK_IMAGE_LAYOUT* pColorLayouts; - const VK_ATTACHMENT_LOAD_OP* pColorLoadOps; - const VK_ATTACHMENT_STORE_OP* pColorStoreOps; - const VK_CLEAR_COLOR* pColorLoadClearValues; - VK_FORMAT depthStencilFormat; - VK_IMAGE_LAYOUT depthStencilLayout; - VK_ATTACHMENT_LOAD_OP depthLoadOp; + const VkFormat* pColorFormats; + const VkImageLayout* pColorLayouts; + const VkAttachmentLoadOp* pColorLoadOps; + const VkAttachmentStoreOp* pColorStoreOps; + const VkClearColor* pColorLoadClearValues; + VkFormat depthStencilFormat; + VkImageLayout depthStencilLayout; + VkAttachmentLoadOp depthLoadOp; float depthLoadClearValue; - VK_ATTACHMENT_STORE_OP depthStoreOp; - VK_ATTACHMENT_LOAD_OP stencilLoadOp; + VkAttachmentStoreOp depthStoreOp; + VkAttachmentLoadOp stencilLoadOp; uint32_t stencilLoadClearValue; - VK_ATTACHMENT_STORE_OP stencilStoreOp; -} VK_RENDER_PASS_CREATE_INFO; + VkAttachmentStoreOp stencilStoreOp; +} VkRenderPassCreateInfo; -typedef struct _VK_EVENT_CREATE_INFO +typedef struct VkEventCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO const void* pNext; // Pointer to next structure - VK_FLAGS flags; // Reserved -} VK_EVENT_CREATE_INFO; + VkFlags flags; // Reserved +} VkEventCreateInfo; -typedef struct _VK_FENCE_CREATE_INFO +typedef struct VkFenceCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO const void* pNext; // Pointer to next structure - VK_FENCE_CREATE_FLAGS flags; // VK_FENCE_CREATE_FLAGS -} VK_FENCE_CREATE_INFO; + VkFenceCreateFlags flags; // VkFenceCreateFlags +} VkFenceCreateInfo; -typedef struct _VK_SEMAPHORE_CREATE_INFO +typedef struct VkSemaphoreCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t initialCount; - VK_FLAGS flags; // VK_SEMAPHORE_CREATE_FLAGS -} VK_SEMAPHORE_CREATE_INFO; + VkFlags flags; // VkSemaphoreCreateFlags +} VkSemaphoreCreateInfo; -typedef struct _VK_SEMAPHORE_OPEN_INFO +typedef struct VkSemaphoreOpenInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO const void* pNext; // Pointer to next structure - VK_SEMAPHORE sharedSemaphore; -} VK_SEMAPHORE_OPEN_INFO; + VkSemaphore sharedSemaphore; +} VkSemaphoreOpenInfo; -typedef struct _VK_PIPELINE_STATISTICS_DATA +typedef struct VkPipelineStatisticsData_ { uint64_t fsInvocations; // Fragment shader invocations uint64_t cPrimitives; // Clipper primitives @@ -2215,219 +2215,219 @@ typedef struct _VK_PIPELINE_STATISTICS_DATA uint64_t tcsInvocations; // Tessellation control shader invocations uint64_t tesInvocations; // Tessellation evaluation shader invocations uint64_t csInvocations; // Compute shader invocations -} VK_PIPELINE_STATISTICS_DATA; +} VkPipelineStatisticsData; -typedef struct _VK_QUERY_POOL_CREATE_INFO +typedef struct VkQueryPoolCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO const void* pNext; // Pointer to next structure - VK_QUERY_TYPE queryType; + VkQueryType queryType; uint32_t slots; -} VK_QUERY_POOL_CREATE_INFO; +} VkQueryPoolCreateInfo; -typedef struct _VK_FRAMEBUFFER_CREATE_INFO +typedef struct VkFramebufferCreateInfo_ { - VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO const void* pNext; // Pointer to next structure uint32_t colorAttachmentCount; - const VK_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments; - const VK_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment; + const VkColorAttachmentBindInfo* pColorAttachments; + const VkDepthStencilBindInfo* pDepthStencilAttachment; uint32_t sampleCount; uint32_t width; uint32_t height; uint32_t layers; -} VK_FRAMEBUFFER_CREATE_INFO; +} VkFramebufferCreateInfo; -typedef struct _VK_DRAW_INDIRECT_CMD +typedef struct VkDrawIndirectCmd_ { uint32_t vertexCount; uint32_t instanceCount; uint32_t firstVertex; uint32_t firstInstance; -} VK_DRAW_INDIRECT_CMD; +} VkDrawIndirectCmd; -typedef struct _VK_DRAW_INDEXED_INDIRECT_CMD +typedef struct VkDrawIndexedIndirectCmd_ { uint32_t indexCount; uint32_t instanceCount; uint32_t firstIndex; int32_t vertexOffset; uint32_t firstInstance; -} VK_DRAW_INDEXED_INDIRECT_CMD; +} VkDrawIndexedIndirectCmd; -typedef struct _VK_DISPATCH_INDIRECT_CMD +typedef struct VkDispatchIndirectCmd_ { uint32_t x; uint32_t y; uint32_t z; -} VK_DISPATCH_INDIRECT_CMD; +} VkDispatchIndirectCmd; // ------------------------------------------------------------------------------------------------ // API functions -typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance); -typedef VK_RESULT (VKAPI *vkDestroyInstanceType)(VK_INSTANCE instance); -typedef VK_RESULT (VKAPI *vkEnumerateGpusType)(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus); -typedef VK_RESULT (VKAPI *vkGetGpuInfoType)(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef void * (VKAPI *vkGetProcAddrType)(VK_PHYSICAL_GPU gpu, const char * pName); -typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice); -typedef VK_RESULT (VKAPI *vkDestroyDeviceType)(VK_DEVICE device); -typedef VK_RESULT (VKAPI *vkGetExtensionSupportType)(VK_PHYSICAL_GPU gpu, const char* pExtName); -typedef VK_RESULT (VKAPI *vkEnumerateLayersType)(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved); -typedef VK_RESULT (VKAPI *vkGetDeviceQueueType)(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue); -typedef VK_RESULT (VKAPI *vkQueueSubmitType)(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence); -typedef VK_RESULT (VKAPI *vkQueueAddMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem); -typedef VK_RESULT (VKAPI *vkQueueRemoveMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem); -typedef VK_RESULT (VKAPI *vkQueueWaitIdleType)(VK_QUEUE queue); -typedef VK_RESULT (VKAPI *vkDeviceWaitIdleType)(VK_DEVICE device); -typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem); -typedef VK_RESULT (VKAPI *vkFreeMemoryType)(VK_GPU_MEMORY mem); -typedef VK_RESULT (VKAPI *vkSetMemoryPriorityType)(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority); -typedef VK_RESULT (VKAPI *vkMapMemoryType)(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData); -typedef VK_RESULT (VKAPI *vkUnmapMemoryType)(VK_GPU_MEMORY mem); -typedef VK_RESULT (VKAPI *vkPinSystemMemoryType)(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem); -typedef VK_RESULT (VKAPI *vkGetMultiGpuCompatibilityType)(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo); -typedef VK_RESULT (VKAPI *vkOpenSharedMemoryType)(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem); -typedef VK_RESULT (VKAPI *vkOpenSharedSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore); -typedef VK_RESULT (VKAPI *vkOpenPeerMemoryType)(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem); -typedef VK_RESULT (VKAPI *vkOpenPeerImageType)(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem); -typedef VK_RESULT (VKAPI *vkDestroyObjectType)(VK_OBJECT object); -typedef VK_RESULT (VKAPI *vkGetObjectInfoType)(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef VK_RESULT (VKAPI *vkBindObjectMemoryType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset); -typedef VK_RESULT (VKAPI *vkBindObjectMemoryRangeType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset,VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset); -typedef VK_RESULT (VKAPI *vkBindImageMemoryRangeType)(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset); -typedef VK_RESULT (VKAPI *vkCreateFenceType)(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence); -typedef VK_RESULT (VKAPI *vkResetFencesType)(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences); -typedef VK_RESULT (VKAPI *vkGetFenceStatusType)(VK_FENCE fence); -typedef VK_RESULT (VKAPI *vkWaitForFencesType)(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout); -typedef VK_RESULT (VKAPI *vkCreateSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore); -typedef VK_RESULT (VKAPI *vkQueueSignalSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore); -typedef VK_RESULT (VKAPI *vkQueueWaitSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore); -typedef VK_RESULT (VKAPI *vkCreateEventType)(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent); -typedef VK_RESULT (VKAPI *vkGetEventStatusType)(VK_EVENT event); -typedef VK_RESULT (VKAPI *vkSetEventType)(VK_EVENT event); -typedef VK_RESULT (VKAPI *vkResetEventType)(VK_EVENT event); -typedef VK_RESULT (VKAPI *vkCreateQueryPoolType)(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool); -typedef VK_RESULT (VKAPI *vkGetQueryPoolResultsType)(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData); -typedef VK_RESULT (VKAPI *vkGetFormatInfoType)(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer); -typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView); -typedef VK_RESULT (VKAPI *vkCreateImageType)(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage); -typedef VK_RESULT (VKAPI *vkGetImageSubresourceInfoType)(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData); -typedef VK_RESULT (VKAPI *vkCreateImageViewType)(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView); -typedef VK_RESULT (VKAPI *vkCreateColorAttachmentViewType)(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView); -typedef VK_RESULT (VKAPI *vkCreateDepthStencilViewType)(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView); -typedef VK_RESULT (VKAPI *vkCreateShaderType)(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader); -typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline); -typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineDerivativeType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline); -typedef VK_RESULT (VKAPI *vkCreateComputePipelineType)(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline); -typedef VK_RESULT (VKAPI *vkStorePipelineType)(VK_PIPELINE pipeline, size_t* pDataSize, void* pData); -typedef VK_RESULT (VKAPI *vkLoadPipelineType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline); -typedef VK_RESULT (VKAPI *vkLoadPipelineDerivativeType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline); -typedef VK_RESULT (VKAPI *vkCreateSamplerType)(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler); -typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutType)(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); -typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutChainType)(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); -typedef VK_RESULT (VKAPI *vkBeginDescriptorPoolUpdateType)(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode); -typedef VK_RESULT (VKAPI *vkEndDescriptorPoolUpdateType)(VK_DEVICE device, VK_CMD_BUFFER cmd); -typedef VK_RESULT (VKAPI *vkCreateDescriptorPoolType)(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool); -typedef VK_RESULT (VKAPI *vkResetDescriptorPoolType)(VK_DESCRIPTOR_POOL descriptorPool); -typedef VK_RESULT (VKAPI *vkAllocDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount); -typedef void (VKAPI *vkClearDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets); -typedef void (VKAPI *vkUpdateDescriptorsType)(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** pUpdateArray); -typedef VK_RESULT (VKAPI *vkCreateDynamicViewportStateType)(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState); -typedef VK_RESULT (VKAPI *vkCreateDynamicRasterStateType)(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState); -typedef VK_RESULT (VKAPI *vkCreateDynamicColorBlendStateType)(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState); -typedef VK_RESULT (VKAPI *vkCreateDynamicDepthStencilStateType)(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState); -typedef VK_RESULT (VKAPI *vkCreateCommandBufferType)(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer); -typedef VK_RESULT (VKAPI *vkBeginCommandBufferType)(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); -typedef VK_RESULT (VKAPI *vkEndCommandBufferType)(VK_CMD_BUFFER cmdBuffer); -typedef VK_RESULT (VKAPI *vkResetCommandBufferType)(VK_CMD_BUFFER cmdBuffer); -typedef void (VKAPI *vkCmdBindPipelineType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline); -typedef void (VKAPI *vkCmdBindDynamicStateObjectType)(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state); -typedef void (VKAPI *vkCmdBindDescriptorSetsType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData); -typedef void (VKAPI *vkCmdBindIndexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType); -typedef void (VKAPI *vkCmdBindVertexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding); -typedef void (VKAPI *vkCmdDrawType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *vkCmdDrawIndexedType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *vkCmdDrawIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *vkCmdDrawIndexedIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *vkCmdDispatchType)(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -typedef void (VKAPI *vkCmdDispatchIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset); -typedef void (VKAPI *vkCmdCopyBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions); -typedef void (VKAPI *vkCmdCopyImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions); -typedef void (VKAPI *vkCmdBlitImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions); -typedef void (VKAPI *vkCmdCopyBufferToImageType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions); -typedef void (VKAPI *vkCmdCopyImageToBufferType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions); -typedef void (VKAPI *vkCmdCloneImageDataType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout); -typedef void (VKAPI *vkCmdUpdateBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData); -typedef void (VKAPI *vkCmdFillBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data); -typedef void (VKAPI *vkCmdClearColorImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); -typedef void (VKAPI *vkCmdClearDepthStencilType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); -typedef void (VKAPI *vkCmdResolveImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects); -typedef void (VKAPI *vkCmdSetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent); -typedef void (VKAPI *vkCmdResetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent); -typedef void (VKAPI *vkCmdWaitEventsType)(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo); -typedef void (VKAPI *vkCmdPipelineBarrierType)(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier); -typedef void (VKAPI *vkCmdBeginQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags); -typedef void (VKAPI *vkCmdEndQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot); -typedef void (VKAPI *vkCmdResetQueryPoolType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount); -typedef void (VKAPI *vkCmdWriteTimestampType)(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset); -typedef void (VKAPI *vkCmdInitAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); -typedef void (VKAPI *vkCmdLoadAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset); -typedef void (VKAPI *vkCmdSaveAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset); -typedef VK_RESULT (VKAPI *vkCreateFramebufferType)(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer); -typedef VK_RESULT (VKAPI *vkCreateRenderPassType)(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass); -typedef void (VKAPI *vkCmdBeginRenderPassType)(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin); -typedef void (VKAPI *vkCmdEndRenderPassType)(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass); +typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); +typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); +typedef VkResult (VKAPI *PFN_vkEnumerateGpus)(VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, VkPhysicalGpu* pGpus); +typedef VkResult (VKAPI *PFN_vkGetGpuInfo)(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData); +typedef void * (VKAPI *PFN_vkGetProcAddr)(VkPhysicalGpu gpu, const char * pName); +typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); +typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkGetExtensionSupport)(VkPhysicalGpu gpu, const char* pExtName); +typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved); +typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); +typedef VkResult (VKAPI *PFN_vkQueueAddMemReference)(VkQueue queue, VkGpuMemory mem); +typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReference)(VkQueue queue, VkGpuMemory mem); +typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkGpuMemory mem); +typedef VkResult (VKAPI *PFN_vkSetMemoryPriority)(VkGpuMemory mem, VkMemoryPriority priority); +typedef VkResult (VKAPI *PFN_vkMapMemory)(VkGpuMemory mem, VkFlags flags, void** ppData); +typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkGpuMemory mem); +typedef VkResult (VKAPI *PFN_vkPinSystemMemory)(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkGetMultiGpuCompatibility)(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo); +typedef VkResult (VKAPI *PFN_vkOpenSharedMemory)(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkOpenSharedSemaphore)(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore); +typedef VkResult (VKAPI *PFN_vkOpenPeerMemory)(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem); +typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* 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_vkBindObjectMemory)(VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset); +typedef VkResult (VKAPI *PFN_vkBindObjectMemoryRange)(VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset,VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset); +typedef VkResult (VKAPI *PFN_vkBindImageMemoryRange)(VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* bindInfo, VkGpuMemory mem, VkGpuSize 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_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_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); +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_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); +typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); +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_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_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayoutChain)(VkDevice device, uint32_t setLayoutArrayCount, const VkDescriptorSetLayout* pSetLayoutArray, VkDescriptorSetLayoutChain* pLayoutChain); +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** pUpdateArray); +typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState); +typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); +typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); +typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer); +typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI *PFN_vkCmdBindDynamicStateObject)(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state); +typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData); +typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType); +typedef void (VKAPI *PFN_vkCmdBindVertexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding); +typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); +typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset); +typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCloneImageData)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout); +typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData); +typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data); +typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearDepthStencil)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t rectCount, const VkImageResolve* pRects); +typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); +typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent); +typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo); +typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier); +typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags); +typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); +typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); +typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset); +typedef void (VKAPI *PFN_vkCmdInitAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); +typedef void (VKAPI *PFN_vkCmdLoadAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset); +typedef void (VKAPI *PFN_vkCmdSaveAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset); +typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); +typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); +typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin); +typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer, VkRenderPass renderPass); #ifdef VK_PROTOTYPES // GPU initialization -VK_RESULT VKAPI vkCreateInstance( +VkResult VKAPI vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, - VK_INSTANCE* pInstance); + VkInstance* pInstance); -VK_RESULT VKAPI vkDestroyInstance( - VK_INSTANCE instance); +VkResult VKAPI vkDestroyInstance( + VkInstance instance); -VK_RESULT VKAPI vkEnumerateGpus( - VK_INSTANCE instance, +VkResult VKAPI vkEnumerateGpus( + VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, - VK_PHYSICAL_GPU* pGpus); + VkPhysicalGpu* pGpus); -VK_RESULT VKAPI vkGetGpuInfo( - VK_PHYSICAL_GPU gpu, - VK_PHYSICAL_GPU_INFO_TYPE infoType, +VkResult VKAPI vkGetGpuInfo( + VkPhysicalGpu gpu, + VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData); void * VKAPI vkGetProcAddr( - VK_PHYSICAL_GPU gpu, + VkPhysicalGpu gpu, const char* pName); // Device functions -VK_RESULT VKAPI vkCreateDevice( - VK_PHYSICAL_GPU gpu, +VkResult VKAPI vkCreateDevice( + VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, - VK_DEVICE* pDevice); + VkDevice* pDevice); -VK_RESULT VKAPI vkDestroyDevice( - VK_DEVICE device); +VkResult VKAPI vkDestroyDevice( + VkDevice device); // Extension discovery functions -VK_RESULT VKAPI vkGetExtensionSupport( - VK_PHYSICAL_GPU gpu, +VkResult VKAPI vkGetExtensionSupport( + VkPhysicalGpu gpu, const char* pExtName); // Layer discovery functions -VK_RESULT VKAPI vkEnumerateLayers( - VK_PHYSICAL_GPU gpu, +VkResult VKAPI vkEnumerateLayers( + VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, @@ -2436,182 +2436,182 @@ VK_RESULT VKAPI vkEnumerateLayers( // Queue functions -VK_RESULT VKAPI vkGetDeviceQueue( - VK_DEVICE device, +VkResult VKAPI vkGetDeviceQueue( + VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, - VK_QUEUE* pQueue); + VkQueue* pQueue); -VK_RESULT VKAPI vkQueueSubmit( - VK_QUEUE queue, +VkResult VKAPI vkQueueSubmit( + VkQueue queue, uint32_t cmdBufferCount, - const VK_CMD_BUFFER* pCmdBuffers, - VK_FENCE fence); + const VkCmdBuffer* pCmdBuffers, + VkFence fence); -VK_RESULT VKAPI vkQueueAddMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); +VkResult VKAPI vkQueueAddMemReference( + VkQueue queue, + VkGpuMemory mem); -VK_RESULT VKAPI vkQueueRemoveMemReference( - VK_QUEUE queue, - VK_GPU_MEMORY mem); +VkResult VKAPI vkQueueRemoveMemReference( + VkQueue queue, + VkGpuMemory mem); -VK_RESULT VKAPI vkQueueWaitIdle( - VK_QUEUE queue); +VkResult VKAPI vkQueueWaitIdle( + VkQueue queue); -VK_RESULT VKAPI vkDeviceWaitIdle( - VK_DEVICE device); +VkResult VKAPI vkDeviceWaitIdle( + VkDevice device); // Memory functions -VK_RESULT VKAPI vkAllocMemory( - VK_DEVICE device, +VkResult VKAPI vkAllocMemory( + VkDevice device, const VkMemoryAllocInfo* pAllocInfo, - VK_GPU_MEMORY* pMem); + VkGpuMemory* pMem); -VK_RESULT VKAPI vkFreeMemory( - VK_GPU_MEMORY mem); +VkResult VKAPI vkFreeMemory( + VkGpuMemory mem); -VK_RESULT VKAPI vkSetMemoryPriority( - VK_GPU_MEMORY mem, - VK_MEMORY_PRIORITY priority); +VkResult VKAPI vkSetMemoryPriority( + VkGpuMemory mem, + VkMemoryPriority priority); -VK_RESULT VKAPI vkMapMemory( - VK_GPU_MEMORY mem, - VK_FLAGS flags, // Reserved +VkResult VKAPI vkMapMemory( + VkGpuMemory mem, + VkFlags flags, // Reserved void** ppData); -VK_RESULT VKAPI vkUnmapMemory( - VK_GPU_MEMORY mem); +VkResult VKAPI vkUnmapMemory( + VkGpuMemory mem); -VK_RESULT VKAPI vkPinSystemMemory( - VK_DEVICE device, +VkResult VKAPI vkPinSystemMemory( + VkDevice device, const void* pSysMem, size_t memSize, - VK_GPU_MEMORY* pMem); + VkGpuMemory* pMem); // Multi-device functions -VK_RESULT VKAPI vkGetMultiGpuCompatibility( - VK_PHYSICAL_GPU gpu0, - VK_PHYSICAL_GPU gpu1, - VK_GPU_COMPATIBILITY_INFO* pInfo); +VkResult VKAPI vkGetMultiGpuCompatibility( + VkPhysicalGpu gpu0, + VkPhysicalGpu gpu1, + VkGpuCompatibilityInfo* pInfo); -VK_RESULT VKAPI vkOpenSharedMemory( - VK_DEVICE device, - const VK_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem); +VkResult VKAPI vkOpenSharedMemory( + VkDevice device, + const VkMemoryOpenInfo* pOpenInfo, + VkGpuMemory* pMem); -VK_RESULT VKAPI vkOpenSharedSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, - VK_SEMAPHORE* pSemaphore); +VkResult VKAPI vkOpenSharedSemaphore( + VkDevice device, + const VkSemaphoreOpenInfo* pOpenInfo, + VkSemaphore* pSemaphore); -VK_RESULT VKAPI vkOpenPeerMemory( - VK_DEVICE device, - const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, - VK_GPU_MEMORY* pMem); +VkResult VKAPI vkOpenPeerMemory( + VkDevice device, + const VkPeerMemoryOpenInfo* pOpenInfo, + VkGpuMemory* pMem); -VK_RESULT VKAPI vkOpenPeerImage( - VK_DEVICE device, - const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, - VK_IMAGE* pImage, - VK_GPU_MEMORY* pMem); +VkResult VKAPI vkOpenPeerImage( + VkDevice device, + const VkPeerImageOpenInfo* pOpenInfo, + VkImage* pImage, + VkGpuMemory* pMem); // Generic API object functions -VK_RESULT VKAPI vkDestroyObject( - VK_OBJECT object); +VkResult VKAPI vkDestroyObject( + VkObject object); -VK_RESULT VKAPI vkGetObjectInfo( - VK_BASE_OBJECT object, - VK_OBJECT_INFO_TYPE infoType, +VkResult VKAPI vkGetObjectInfo( + VkBaseObject object, + VkObjectInfoType infoType, size_t* pDataSize, void* pData); -VK_RESULT VKAPI vkBindObjectMemory( - VK_OBJECT object, +VkResult VKAPI vkBindObjectMemory( + VkObject object, uint32_t allocationIdx, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); + VkGpuMemory mem, + VkGpuSize memOffset); -VK_RESULT VKAPI vkBindObjectMemoryRange( - VK_OBJECT object, +VkResult VKAPI vkBindObjectMemoryRange( + VkObject object, uint32_t allocationIdx, - VK_GPU_SIZE rangeOffset, - VK_GPU_SIZE rangeSize, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); + VkGpuSize rangeOffset, + VkGpuSize rangeSize, + VkGpuMemory mem, + VkGpuSize memOffset); -VK_RESULT VKAPI vkBindImageMemoryRange( - VK_IMAGE image, +VkResult VKAPI vkBindImageMemoryRange( + VkImage image, uint32_t allocationIdx, - const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, - VK_GPU_MEMORY mem, - VK_GPU_SIZE memOffset); + const VkImageMemoryBindInfo* bindInfo, + VkGpuMemory mem, + VkGpuSize memOffset); // Fence functions -VK_RESULT VKAPI vkCreateFence( - VK_DEVICE device, - const VK_FENCE_CREATE_INFO* pCreateInfo, - VK_FENCE* pFence); +VkResult VKAPI vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence); -VK_RESULT VKAPI vkResetFences( - VK_DEVICE device, +VkResult VKAPI vkResetFences( + VkDevice device, uint32_t fenceCount, - VK_FENCE* pFences); + VkFence* pFences); -VK_RESULT VKAPI vkGetFenceStatus( - VK_FENCE fence); +VkResult VKAPI vkGetFenceStatus( + VkFence fence); -VK_RESULT VKAPI vkWaitForFences( - VK_DEVICE device, +VkResult VKAPI vkWaitForFences( + VkDevice device, uint32_t fenceCount, - const VK_FENCE* pFences, + const VkFence* pFences, bool32_t waitAll, uint64_t timeout); // timeout in nanoseconds // Queue semaphore functions -VK_RESULT VKAPI vkCreateSemaphore( - VK_DEVICE device, - const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, - VK_SEMAPHORE* pSemaphore); +VkResult VKAPI vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + VkSemaphore* pSemaphore); -VK_RESULT VKAPI vkQueueSignalSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); +VkResult VKAPI vkQueueSignalSemaphore( + VkQueue queue, + VkSemaphore semaphore); -VK_RESULT VKAPI vkQueueWaitSemaphore( - VK_QUEUE queue, - VK_SEMAPHORE semaphore); +VkResult VKAPI vkQueueWaitSemaphore( + VkQueue queue, + VkSemaphore semaphore); // Event functions -VK_RESULT VKAPI vkCreateEvent( - VK_DEVICE device, - const VK_EVENT_CREATE_INFO* pCreateInfo, - VK_EVENT* pEvent); +VkResult VKAPI vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + VkEvent* pEvent); -VK_RESULT VKAPI vkGetEventStatus( - VK_EVENT event); +VkResult VKAPI vkGetEventStatus( + VkEvent event); -VK_RESULT VKAPI vkSetEvent( - VK_EVENT event); +VkResult VKAPI vkSetEvent( + VkEvent event); -VK_RESULT VKAPI vkResetEvent( - VK_EVENT event); +VkResult VKAPI vkResetEvent( + VkEvent event); // Query functions -VK_RESULT VKAPI vkCreateQueryPool( - VK_DEVICE device, - const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, - VK_QUERY_POOL* pQueryPool); +VkResult VKAPI vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool); -VK_RESULT VKAPI vkGetQueryPoolResults( - VK_QUERY_POOL queryPool, +VkResult VKAPI vkGetQueryPoolResults( + VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, @@ -2619,238 +2619,238 @@ VK_RESULT VKAPI vkGetQueryPoolResults( // Format capabilities -VK_RESULT VKAPI vkGetFormatInfo( - VK_DEVICE device, - VK_FORMAT format, - VK_FORMAT_INFO_TYPE infoType, +VkResult VKAPI vkGetFormatInfo( + VkDevice device, + VkFormat format, + VkFormatInfoType infoType, size_t* pDataSize, void* pData); // Buffer functions -VK_RESULT VKAPI vkCreateBuffer( - VK_DEVICE device, +VkResult VKAPI vkCreateBuffer( + VkDevice device, const VkBufferCreateInfo* pCreateInfo, - VK_BUFFER* pBuffer); + VkBuffer* pBuffer); // Buffer view functions -VK_RESULT VKAPI vkCreateBufferView( - VK_DEVICE device, +VkResult VKAPI vkCreateBufferView( + VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, - VK_BUFFER_VIEW* pView); + VkBufferView* pView); // Image functions -VK_RESULT VKAPI vkCreateImage( - VK_DEVICE device, - const VK_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage); +VkResult VKAPI vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + VkImage* pImage); -VK_RESULT VKAPI vkGetImageSubresourceInfo( - VK_IMAGE image, - const VK_IMAGE_SUBRESOURCE* pSubresource, - VK_SUBRESOURCE_INFO_TYPE infoType, +VkResult VKAPI vkGetImageSubresourceInfo( + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceInfoType infoType, size_t* pDataSize, void* pData); // Image view functions -VK_RESULT VKAPI vkCreateImageView( - VK_DEVICE device, - const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, - VK_IMAGE_VIEW* pView); +VkResult VKAPI vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + VkImageView* pView); -VK_RESULT VKAPI vkCreateColorAttachmentView( - VK_DEVICE device, - const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - VK_COLOR_ATTACHMENT_VIEW* pView); +VkResult VKAPI vkCreateColorAttachmentView( + VkDevice device, + const VkColorAttachmentViewCreateInfo* pCreateInfo, + VkColorAttachmentView* pView); -VK_RESULT VKAPI vkCreateDepthStencilView( - VK_DEVICE device, - const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, - VK_DEPTH_STENCIL_VIEW* pView); +VkResult VKAPI vkCreateDepthStencilView( + VkDevice device, + const VkDepthStencilViewCreateInfo* pCreateInfo, + VkDepthStencilView* pView); // Shader functions -VK_RESULT VKAPI vkCreateShader( - VK_DEVICE device, - const VK_SHADER_CREATE_INFO* pCreateInfo, - VK_SHADER* pShader); +VkResult VKAPI vkCreateShader( + VkDevice device, + const VkShaderCreateInfo* pCreateInfo, + VkShader* pShader); // Pipeline functions -VK_RESULT VKAPI vkCreateGraphicsPipeline( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); +VkResult VKAPI vkCreateGraphicsPipeline( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline* pPipeline); -VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); +VkResult VKAPI vkCreateGraphicsPipelineDerivative( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline basePipeline, + VkPipeline* pPipeline); -VK_RESULT VKAPI vkCreateComputePipeline( - VK_DEVICE device, - const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline); +VkResult VKAPI vkCreateComputePipeline( + VkDevice device, + const VkComputePipelineCreateInfo* pCreateInfo, + VkPipeline* pPipeline); -VK_RESULT VKAPI vkStorePipeline( - VK_PIPELINE pipeline, +VkResult VKAPI vkStorePipeline( + VkPipeline pipeline, size_t* pDataSize, void* pData); -VK_RESULT VKAPI vkLoadPipeline( - VK_DEVICE device, +VkResult VKAPI vkLoadPipeline( + VkDevice device, size_t dataSize, const void* pData, - VK_PIPELINE* pPipeline); + VkPipeline* pPipeline); -VK_RESULT VKAPI vkLoadPipelineDerivative( - VK_DEVICE device, +VkResult VKAPI vkLoadPipelineDerivative( + VkDevice device, size_t dataSize, const void* pData, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline); + VkPipeline basePipeline, + VkPipeline* pPipeline); // Sampler functions -VK_RESULT VKAPI vkCreateSampler( - VK_DEVICE device, - const VK_SAMPLER_CREATE_INFO* pCreateInfo, - VK_SAMPLER* pSampler); +VkResult VKAPI vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + VkSampler* pSampler); // Descriptor set functions -VK_RESULT VKAPI vkCreateDescriptorSetLayout( - VK_DEVICE device, - const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_SET_LAYOUT* pSetLayout); +VkResult VKAPI vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayout* pSetLayout); -VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain( - VK_DEVICE device, +VkResult VKAPI vkCreateDescriptorSetLayoutChain( + VkDevice device, uint32_t setLayoutArrayCount, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain); + const VkDescriptorSetLayout* pSetLayoutArray, + VkDescriptorSetLayoutChain* pLayoutChain); -VK_RESULT VKAPI vkBeginDescriptorPoolUpdate( - VK_DEVICE device, - VK_DESCRIPTOR_UPDATE_MODE updateMode); +VkResult VKAPI vkBeginDescriptorPoolUpdate( + VkDevice device, + VkDescriptorUpdateMode updateMode); -VK_RESULT VKAPI vkEndDescriptorPoolUpdate( - VK_DEVICE device, - VK_CMD_BUFFER cmd); +VkResult VKAPI vkEndDescriptorPoolUpdate( + VkDevice device, + VkCmdBuffer cmd); -VK_RESULT VKAPI vkCreateDescriptorPool( - VK_DEVICE device, - VK_DESCRIPTOR_POOL_USAGE poolUsage, +VkResult VKAPI vkCreateDescriptorPool( + VkDevice device, + VkDescriptorPoolUsage poolUsage, uint32_t maxSets, - const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, - VK_DESCRIPTOR_POOL* pDescriptorPool); + const VkDescriptorPoolCreateInfo* pCreateInfo, + VkDescriptorPool* pDescriptorPool); -VK_RESULT VKAPI vkResetDescriptorPool( - VK_DESCRIPTOR_POOL descriptorPool); +VkResult VKAPI vkResetDescriptorPool( + VkDescriptorPool descriptorPool); -VK_RESULT VKAPI vkAllocDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, - VK_DESCRIPTOR_SET_USAGE setUsage, +VkResult VKAPI vkAllocDescriptorSets( + VkDescriptorPool descriptorPool, + VkDescriptorSetUsage setUsage, uint32_t count, - const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, - VK_DESCRIPTOR_SET* pDescriptorSets, + const VkDescriptorSetLayout* pSetLayouts, + VkDescriptorSet* pDescriptorSets, uint32_t* pCount); void VKAPI vkClearDescriptorSets( - VK_DESCRIPTOR_POOL descriptorPool, + VkDescriptorPool descriptorPool, uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets); + const VkDescriptorSet* pDescriptorSets); void VKAPI vkUpdateDescriptors( - VK_DESCRIPTOR_SET descriptorSet, + VkDescriptorSet descriptorSet, uint32_t updateCount, const void** pUpdateArray); // State object functions -VK_RESULT VKAPI vkCreateDynamicViewportState( - VK_DEVICE device, - const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_VP_STATE_OBJECT* pState); +VkResult VKAPI vkCreateDynamicViewportState( + VkDevice device, + const VkDynamicVpStateCreateInfo* pCreateInfo, + VkDynamicVpStateObject* pState); -VK_RESULT VKAPI vkCreateDynamicRasterState( - VK_DEVICE device, - const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_RS_STATE_OBJECT* pState); +VkResult VKAPI vkCreateDynamicRasterState( + VkDevice device, + const VkDynamicRsStateCreateInfo* pCreateInfo, + VkDynamicRsStateObject* pState); -VK_RESULT VKAPI vkCreateDynamicColorBlendState( - VK_DEVICE device, - const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_CB_STATE_OBJECT* pState); +VkResult VKAPI vkCreateDynamicColorBlendState( + VkDevice device, + const VkDynamicCbStateCreateInfo* pCreateInfo, + VkDynamicCbStateObject* pState); -VK_RESULT VKAPI vkCreateDynamicDepthStencilState( - VK_DEVICE device, - const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_DS_STATE_OBJECT* pState); +VkResult VKAPI vkCreateDynamicDepthStencilState( + VkDevice device, + const VkDynamicDsStateCreateInfo* pCreateInfo, + VkDynamicDsStateObject* pState); // Command buffer functions -VK_RESULT VKAPI vkCreateCommandBuffer( - VK_DEVICE device, - const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, - VK_CMD_BUFFER* pCmdBuffer); +VkResult VKAPI vkCreateCommandBuffer( + VkDevice device, + const VkCmdBufferCreateInfo* pCreateInfo, + VkCmdBuffer* pCmdBuffer); -VK_RESULT VKAPI vkBeginCommandBuffer( - VK_CMD_BUFFER cmdBuffer, - const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo); +VkResult VKAPI vkBeginCommandBuffer( + VkCmdBuffer cmdBuffer, + const VkCmdBufferBeginInfo* pBeginInfo); -VK_RESULT VKAPI vkEndCommandBuffer( - VK_CMD_BUFFER cmdBuffer); +VkResult VKAPI vkEndCommandBuffer( + VkCmdBuffer cmdBuffer); -VK_RESULT VKAPI vkResetCommandBuffer( - VK_CMD_BUFFER cmdBuffer); +VkResult VKAPI vkResetCommandBuffer( + VkCmdBuffer cmdBuffer); // Command buffer building functions void VKAPI vkCmdBindPipeline( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_PIPELINE pipeline); + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); void VKAPI vkCmdBindDynamicStateObject( - VK_CMD_BUFFER cmdBuffer, - VK_STATE_BIND_POINT stateBindPoint, - VK_DYNAMIC_STATE_OBJECT dynamicState); + VkCmdBuffer cmdBuffer, + VkStateBindPoint stateBindPoint, + VkDynamicStateObject dynamicState); void VKAPI vkCmdBindDescriptorSets( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets, + const VkDescriptorSet* pDescriptorSets, const uint32_t * pUserData); void VKAPI vkCmdBindIndexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, - VK_INDEX_TYPE indexType); + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, + VkIndexType indexType); void VKAPI vkCmdBindVertexBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, uint32_t binding); void VKAPI vkCmdDraw( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); void VKAPI vkCmdDrawIndexed( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, @@ -2858,198 +2858,198 @@ void VKAPI vkCmdDrawIndexed( uint32_t instanceCount); void VKAPI vkCmdDrawIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, uint32_t count, uint32_t stride); void VKAPI vkCmdDrawIndexedIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset, + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset, uint32_t count, uint32_t stride); void VKAPI vkCmdDispatch( - VK_CMD_BUFFER cmdBuffer, + VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); void VKAPI vkCmdDispatchIndirect( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER buffer, - VK_GPU_SIZE offset); + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkGpuSize offset); void VKAPI vkCmdCopyBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_BUFFER destBuffer, + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkBuffer destBuffer, uint32_t regionCount, - const VK_BUFFER_COPY* pRegions); + const VkBufferCopy* pRegions); void VKAPI vkCmdCopyImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t regionCount, - const VK_IMAGE_COPY* pRegions); + const VkImageCopy* pRegions); void VKAPI vkCmdBlitImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t regionCount, - const VK_IMAGE_BLIT* pRegions); + const VkImageBlit* pRegions); void VKAPI vkCmdCopyBufferToImage( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions); + const VkBufferImageCopy* pRegions); void VKAPI vkCmdCopyImageToBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer destBuffer, uint32_t regionCount, - const VK_BUFFER_IMAGE_COPY* pRegions); + const VkBufferImageCopy* pRegions); void VKAPI vkCmdCloneImageData( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout); + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout); void VKAPI vkCmdUpdateBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset, - VK_GPU_SIZE dataSize, + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkGpuSize destOffset, + VkGpuSize dataSize, const uint32_t* pData); void VKAPI vkCmdFillBuffer( - VK_CMD_BUFFER cmdBuffer, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset, - VK_GPU_SIZE fillSize, + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkGpuSize destOffset, + VkGpuSize fillSize, uint32_t data); void VKAPI vkCmdClearColorImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + VkClearColor color, uint32_t rangeCount, - const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); + const VkImageSubresourceRange* pRanges); void VKAPI vkCmdClearDepthStencil( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, - VK_IMAGE_LAYOUT imageLayout, + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, - const VK_IMAGE_SUBRESOURCE_RANGE* pRanges); + const VkImageSubresourceRange* pRanges); void VKAPI vkCmdResolveImage( - VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, uint32_t rectCount, - const VK_IMAGE_RESOLVE* pRects); + const VkImageResolve* pRects); void VKAPI vkCmdSetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipeEvent pipeEvent); void VKAPI vkCmdResetEvent( - VK_CMD_BUFFER cmdBuffer, - VK_EVENT event, - VK_PIPE_EVENT pipeEvent); + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipeEvent pipeEvent); void VKAPI vkCmdWaitEvents( - VK_CMD_BUFFER cmdBuffer, - const VK_EVENT_WAIT_INFO* pWaitInfo); + VkCmdBuffer cmdBuffer, + const VkEventWaitInfo* pWaitInfo); void VKAPI vkCmdPipelineBarrier( - VK_CMD_BUFFER cmdBuffer, - const VK_PIPELINE_BARRIER* pBarrier); + VkCmdBuffer cmdBuffer, + const VkPipelineBarrier* pBarrier); void VKAPI vkCmdBeginQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, uint32_t slot, - VK_FLAGS flags); + VkFlags flags); void VKAPI vkCmdEndQuery( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, uint32_t slot); void VKAPI vkCmdResetQueryPool( - VK_CMD_BUFFER cmdBuffer, - VK_QUERY_POOL queryPool, + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); void VKAPI vkCmdWriteTimestamp( - VK_CMD_BUFFER cmdBuffer, - VK_TIMESTAMP_TYPE timestampType, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); + VkCmdBuffer cmdBuffer, + VkTimestampType timestampType, + VkBuffer destBuffer, + VkGpuSize destOffset); void VKAPI vkCmdInitAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData); void VKAPI vkCmdLoadAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - VK_BUFFER srcBuffer, - VK_GPU_SIZE srcOffset); + VkBuffer srcBuffer, + VkGpuSize srcOffset); void VKAPI vkCmdSaveAtomicCounters( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, - VK_BUFFER destBuffer, - VK_GPU_SIZE destOffset); + VkBuffer destBuffer, + VkGpuSize destOffset); -VK_RESULT VKAPI vkCreateFramebuffer( - VK_DEVICE device, - const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, - VK_FRAMEBUFFER* pFramebuffer); +VkResult VKAPI vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + VkFramebuffer* pFramebuffer); -VK_RESULT VKAPI vkCreateRenderPass( - VK_DEVICE device, - const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, - VK_RENDER_PASS* pRenderPass); +VkResult VKAPI vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + VkRenderPass* pRenderPass); void VKAPI vkCmdBeginRenderPass( - VK_CMD_BUFFER cmdBuffer, - const VK_RENDER_PASS_BEGIN* pRenderPassBegin); + VkCmdBuffer cmdBuffer, + const VkRenderPassBegin* pRenderPassBegin); void VKAPI vkCmdEndRenderPass( - VK_CMD_BUFFER cmdBuffer, - VK_RENDER_PASS renderPass); + VkCmdBuffer cmdBuffer, + VkRenderPass renderPass); #endif // VK_PROTOTYPES diff --git a/layers/basic.cpp b/layers/basic.cpp index 402adb68..9501c13e 100644 --- a/layers/basic.cpp +++ b/layers/basic.cpp @@ -49,21 +49,21 @@ static VK_LAYER_DISPATCH_TABLE * initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw return it->second; } - layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject); + layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VkPhysicalGpu) gpuw->nextObject); return pTable; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLayerExtension1(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkLayerExtension1(VkDevice device) { printf("In vkLayerExtension1() call w/ device: %p\n", (void*)device); printf("vkLayerExtension1 returning SUCCESS\n"); return VK_SUCCESS; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { - VK_RESULT result; + VkResult result; VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */ @@ -77,7 +77,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const { printf("At start of wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu); VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw]; - result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); printf("Completed wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu); } else { @@ -86,29 +86,29 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw]; printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu); - VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // create a mapping for the device object into the dispatch table tableMap.emplace(*pDevice, pTable); printf("Completed wrapped vkCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap[device]; printf("At start of wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device); - VK_RESULT result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData); + VkResult result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData); printf("Completed wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) { @@ -116,7 +116,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma VK_LAYER_DISPATCH_TABLE* pTable = initLayerTable(gpuw); printf("At start of wrapped vkEnumerateLayers() call w/ gpu: %p\n", gpu); - VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else { @@ -125,11 +125,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma // Example of a layer that is only compatible with Intel's GPUs VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT*) pReserved; - vkGetGpuInfoType fpGetGpuInfo; - VK_PHYSICAL_GPU_PROPERTIES gpuProps; - size_t dataSize = sizeof(VK_PHYSICAL_GPU_PROPERTIES); - fpGetGpuInfo = (vkGetGpuInfoType) gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, "vkGetGpuInfo"); - fpGetGpuInfo((VK_PHYSICAL_GPU) gpuw->nextObject, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps); + PFN_vkGetGpuInfo fpGetGpuInfo; + VkPhysicalGpuProperties gpuProps; + size_t dataSize = sizeof(VkPhysicalGpuProperties); + fpGetGpuInfo = (PFN_vkGetGpuInfo) gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, "vkGetGpuInfo"); + fpGetGpuInfo((VkPhysicalGpu) gpuw->nextObject, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps); if (gpuProps.vendorId == 0x8086) { *pOutLayerCount = 1; @@ -142,7 +142,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* pName) { if (gpu == NULL) return NULL; @@ -165,6 +165,6 @@ VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pNam VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName); + return gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, pName); } } diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index 5e4a95fe..6ff0fcee 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -41,18 +41,18 @@ #include "loader_platform.h" #include "layers_msg.h" -unordered_map sampleMap; -unordered_map imageMap; -unordered_map bufferMap; -unordered_map dynamicStateMap; -unordered_map pipelineMap; -unordered_map poolMap; -unordered_map setMap; -unordered_map layoutMap; +unordered_map sampleMap; +unordered_map imageMap; +unordered_map bufferMap; +unordered_map dynamicStateMap; +unordered_map pipelineMap; +unordered_map poolMap; +unordered_map setMap; +unordered_map layoutMap; // Map for layout chains -unordered_map cmdBufferMap; -unordered_map renderPassMap; -unordered_map frameBufferMap; +unordered_map cmdBufferMap; +unordered_map renderPassMap; +unordered_map frameBufferMap; static VK_LAYER_DISPATCH_TABLE nextTable; static VK_BASE_LAYER_OBJECT *pCurObj; @@ -176,7 +176,7 @@ static uint64_t g_drawCount[NUM_DRAW_TYPES] = {0, 0, 0, 0}; // Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates // to that same cmd buffer by separate thread are not changing state from underneath us // Track the last cmd buffer touched by this thread -static VK_CMD_BUFFER g_lastCmdBuffer[MAX_TID] = {NULL}; +static VkCmdBuffer g_lastCmdBuffer[MAX_TID] = {NULL}; // Track the last group of CBs touched for displaying to dot file static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL}; static uint32_t g_lastTouchedCBIndex = 0; @@ -184,14 +184,14 @@ static uint32_t g_lastTouchedCBIndex = 0; static GLOBAL_CB_NODE* g_lastGlobalCB = NULL; static PIPELINE_NODE* g_lastBoundPipeline = NULL; static DYNAMIC_STATE_NODE* g_lastBoundDynamicState[VK_NUM_STATE_BIND_POINT] = {NULL}; -static VK_DESCRIPTOR_SET g_lastBoundDescriptorSet = NULL; +static VkDescriptorSet g_lastBoundDescriptorSet = NULL; #define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set //static DYNAMIC_STATE_NODE* g_pDynamicStateHead[VK_NUM_STATE_BIND_POINT] = {0}; -static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERIC_HEADER* pCreateInfo, VK_STATE_BIND_POINT bindPoint) +static void insertDynamicState(const VkDynamicStateObject state, const GENERIC_HEADER* pCreateInfo, VkStateBindPoint bindPoint) { - VK_DYNAMIC_VP_STATE_CREATE_INFO* pVPCI = NULL; + VkDynamicVpStateCreateInfo* pVPCI = NULL; size_t scSize = 0; size_t vpSize = 0; loader_platform_thread_lock_mutex(&globalLock); @@ -199,23 +199,23 @@ static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERI pStateNode->stateObj = state; switch (pCreateInfo->sType) { case VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO)); - pVPCI = (VK_DYNAMIC_VP_STATE_CREATE_INFO*)pCreateInfo; - pStateNode->create_info.vpci.pScissors = new VK_RECT[pStateNode->create_info.vpci.viewportAndScissorCount]; - pStateNode->create_info.vpci.pViewports = new VK_VIEWPORT[pStateNode->create_info.vpci.viewportAndScissorCount]; - scSize = pVPCI->viewportAndScissorCount * sizeof(VK_RECT); - vpSize = pVPCI->viewportAndScissorCount * sizeof(VK_VIEWPORT); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo)); + pVPCI = (VkDynamicVpStateCreateInfo*)pCreateInfo; + pStateNode->create_info.vpci.pScissors = new VkRect[pStateNode->create_info.vpci.viewportAndScissorCount]; + pStateNode->create_info.vpci.pViewports = new VkViewport[pStateNode->create_info.vpci.viewportAndScissorCount]; + scSize = pVPCI->viewportAndScissorCount * sizeof(VkRect); + vpSize = pVPCI->viewportAndScissorCount * sizeof(VkViewport); memcpy((void*)pStateNode->create_info.vpci.pScissors, pVPCI->pScissors, scSize); memcpy((void*)pStateNode->create_info.vpci.pViewports, pVPCI->pViewports, vpSize); break; case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO)); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo)); break; case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO)); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo)); break; case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO)); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo)); break; default: assert(0); @@ -228,7 +228,7 @@ static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERI // Free all allocated nodes for Dynamic State objs static void deleteDynamicState() { - for (unordered_map::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) { + for (unordered_map::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) { if (VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) { delete[] (*ii).second->create_info.vpci.pScissors; delete[] (*ii).second->create_info.vpci.pViewports; @@ -239,11 +239,11 @@ static void deleteDynamicState() // Free all sampler nodes static void deleteSamplers() { - for (unordered_map::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) { + for (unordered_map::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) { delete (*ii).second; } } -static VK_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(VK_IMAGE_VIEW view) +static VkImageViewCreateInfo* getImageViewCreateInfo(VkImageView view) { loader_platform_thread_lock_mutex(&globalLock); if (imageMap.find(view) == imageMap.end()) { @@ -258,11 +258,11 @@ static VK_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(VK_IMAGE_VIEW view) // Free all image nodes static void deleteImages() { - for (unordered_map::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) { + for (unordered_map::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) { delete (*ii).second; } } -static VkBufferViewCreateInfo* getBufferViewCreateInfo(VK_BUFFER_VIEW view) +static VkBufferViewCreateInfo* getBufferViewCreateInfo(VkBufferView view) { loader_platform_thread_lock_mutex(&globalLock); if (bufferMap.find(view) == bufferMap.end()) { @@ -277,13 +277,13 @@ static VkBufferViewCreateInfo* getBufferViewCreateInfo(VK_BUFFER_VIEW view) // Free all buffer nodes static void deleteBuffers() { - for (unordered_map::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) { + for (unordered_map::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) { delete (*ii).second; } } -static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb); +static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb); -static void updateCBTracking(VK_CMD_BUFFER cb) +static void updateCBTracking(VkCmdBuffer cb) { g_lastCmdBuffer[getTIDIndex()] = cb; GLOBAL_CB_NODE* pCB = getCBNode(cb); @@ -302,7 +302,7 @@ static void updateCBTracking(VK_CMD_BUFFER cb) } // Print the last bound dynamic state -static void printDynamicState(const VK_CMD_BUFFER cb) +static void printDynamicState(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -310,13 +310,13 @@ static void printDynamicState(const VK_CMD_BUFFER cb) char str[4*1024]; for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) { if (pCB->lastBoundDynamicState[i]) { - sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i), pCB->lastBoundDynamicState[i]->stateObj); + sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_VkStateBindPoint((VkStateBindPoint)i), pCB->lastBoundDynamicState[i]->stateObj); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", str); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, " ").c_str()); break; } else { - sprintf(str, "No dynamic state of type %s bound", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i)); + sprintf(str, "No dynamic state of type %s bound", string_VkStateBindPoint((VkStateBindPoint)i)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str); } } @@ -329,7 +329,7 @@ static void printDynamicState(const VK_CMD_BUFFER cb) } } // Retrieve pipeline node ptr for given pipeline object -static PIPELINE_NODE* getPipeline(VK_PIPELINE pipeline) +static PIPELINE_NODE* getPipeline(VkPipeline pipeline) { loader_platform_thread_lock_mutex(&globalLock); if (pipelineMap.find(pipeline) == pipelineMap.end()) { @@ -341,7 +341,7 @@ static PIPELINE_NODE* getPipeline(VK_PIPELINE pipeline) } // For given sampler, return a ptr to its Create Info struct, or NULL if sampler not found -static VK_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const VK_SAMPLER sampler) +static VkSamplerCreateInfo* getSamplerCreateInfo(const VkSampler sampler) { loader_platform_thread_lock_mutex(&globalLock); if (sampleMap.find(sampler) == sampleMap.end()) { @@ -354,49 +354,49 @@ static VK_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const VK_SAMPLER sampler) // Init the pipeline mapping info based on pipeline create info LL tree // Threading note : Calls to this function should wrapped in mutex -static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo) +static void initPipeline(PIPELINE_NODE* pPipeline, const VkGraphicsPipelineCreateInfo* pCreateInfo) { // First init create info, we'll shadow the structs as we go down the tree // TODO : Validate that no create info is incorrectly replicated - memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO)); + memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo)); GENERIC_HEADER* pTrav = (GENERIC_HEADER*)pCreateInfo->pNext; GENERIC_HEADER* pPrev = (GENERIC_HEADER*)&pPipeline->graphicsPipelineCI; // Hold prev ptr to tie chain of structs together size_t bufferSize = 0; - VK_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVICI = NULL; - VK_PIPELINE_CB_STATE_CREATE_INFO* pCBCI = NULL; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO* pTmpPSSCI = NULL; + VkPipelineVertexInputCreateInfo* pVICI = NULL; + VkPipelineCbStateCreateInfo* pCBCI = NULL; + VkPipelineShaderStageCreateInfo* pTmpPSSCI = NULL; while (pTrav) { switch (pTrav->sType) { case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: - pTmpPSSCI = (VK_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav; + pTmpPSSCI = (VkPipelineShaderStageCreateInfo*)pTrav; switch (pTmpPSSCI->shader.stage) { case VK_SHADER_STAGE_VERTEX: pPrev->pNext = &pPipeline->vsCI; pPrev = (GENERIC_HEADER*)&pPipeline->vsCI; - memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_TESS_CONTROL: pPrev->pNext = &pPipeline->tcsCI; pPrev = (GENERIC_HEADER*)&pPipeline->tcsCI; - memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_TESS_EVALUATION: pPrev->pNext = &pPipeline->tesCI; pPrev = (GENERIC_HEADER*)&pPipeline->tesCI; - memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_GEOMETRY: pPrev->pNext = &pPipeline->gsCI; pPrev = (GENERIC_HEADER*)&pPipeline->gsCI; - memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_FRAGMENT: pPrev->pNext = &pPipeline->fsCI; pPrev = (GENERIC_HEADER*)&pPipeline->fsCI; - memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_COMPUTE: - // TODO : Flag error, CS is specified through VK_COMPUTE_PIPELINE_CREATE_INFO + // TODO : Flag error, CS is specified through VkComputePipelineCreateInfo break; default: // TODO : Flag error @@ -406,64 +406,64 @@ static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CR case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: pPrev->pNext = &pPipeline->vertexInputCI; pPrev = (GENERIC_HEADER*)&pPipeline->vertexInputCI; - memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(VK_PIPELINE_VERTEX_INPUT_CREATE_INFO)); + memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(VkPipelineVertexInputCreateInfo)); // Copy embedded ptrs - pVICI = (VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav; + pVICI = (VkPipelineVertexInputCreateInfo*)pTrav; pPipeline->vtxBindingCount = pVICI->bindingCount; if (pPipeline->vtxBindingCount) { - pPipeline->pVertexBindingDescriptions = new VK_VERTEX_INPUT_BINDING_DESCRIPTION[pPipeline->vtxBindingCount]; - bufferSize = pPipeline->vtxBindingCount * sizeof(VK_VERTEX_INPUT_BINDING_DESCRIPTION); - memcpy((void*)pPipeline->pVertexBindingDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize); + pPipeline->pVertexBindingDescriptions = new VkVertexInputBindingDescription[pPipeline->vtxBindingCount]; + bufferSize = pPipeline->vtxBindingCount * sizeof(VkVertexInputBindingDescription); + memcpy((void*)pPipeline->pVertexBindingDescriptions, ((VkPipelineVertexInputCreateInfo*)pTrav)->pVertexAttributeDescriptions, bufferSize); } pPipeline->vtxAttributeCount = pVICI->attributeCount; if (pPipeline->vtxAttributeCount) { - pPipeline->pVertexAttributeDescriptions = new VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION[pPipeline->vtxAttributeCount]; - bufferSize = pPipeline->vtxAttributeCount * sizeof(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION); - memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize); + pPipeline->pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[pPipeline->vtxAttributeCount]; + bufferSize = pPipeline->vtxAttributeCount * sizeof(VkVertexInputAttributeDescription); + memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((VkPipelineVertexInputCreateInfo*)pTrav)->pVertexAttributeDescriptions, bufferSize); } break; case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->iaStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->iaStateCI; - memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(VK_PIPELINE_IA_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(VkPipelineIaStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->tessStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->tessStateCI; - memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(VK_PIPELINE_TESS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(VkPipelineTessStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->vpStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->vpStateCI; - memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(VK_PIPELINE_VP_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(VkPipelineVpStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->rsStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->rsStateCI; - memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(VK_PIPELINE_RS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(VkPipelineRsStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->msStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->msStateCI; - memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(VK_PIPELINE_MS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(VkPipelineMsStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->cbStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->cbStateCI; - memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(VK_PIPELINE_CB_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(VkPipelineCbStateCreateInfo)); // Copy embedded ptrs - pCBCI = (VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav; + pCBCI = (VkPipelineCbStateCreateInfo*)pTrav; pPipeline->attachmentCount = pCBCI->attachmentCount; if (pPipeline->attachmentCount) { - pPipeline->pAttachments = new VK_PIPELINE_CB_ATTACHMENT_STATE[pPipeline->attachmentCount]; - bufferSize = pPipeline->attachmentCount * sizeof(VK_PIPELINE_CB_ATTACHMENT_STATE); - memcpy((void*)pPipeline->pAttachments, ((VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav)->pAttachments, bufferSize); + pPipeline->pAttachments = new VkPipelineCbAttachmentState[pPipeline->attachmentCount]; + bufferSize = pPipeline->attachmentCount * sizeof(VkPipelineCbAttachmentState); + memcpy((void*)pPipeline->pAttachments, ((VkPipelineCbStateCreateInfo*)pTrav)->pAttachments, bufferSize); } break; case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->dsStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->dsStateCI; - memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(VK_PIPELINE_DS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(VkPipelineDsStateCreateInfo)); break; default: assert(0); @@ -476,7 +476,7 @@ static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CR // Free the Pipeline nodes static void deletePipelines() { - for (unordered_map::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) { + for (unordered_map::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) { if ((*ii).second->pVertexBindingDescriptions) { delete[] (*ii).second->pVertexBindingDescriptions; } @@ -490,7 +490,7 @@ static void deletePipelines() } } // For given pipeline, return number of MSAA samples, or one if MSAA disabled -static uint32_t getNumSamples(const VK_PIPELINE pipeline) +static uint32_t getNumSamples(const VkPipeline pipeline) { PIPELINE_NODE* pPipe = pipelineMap[pipeline]; if (VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) { @@ -500,14 +500,14 @@ static uint32_t getNumSamples(const VK_PIPELINE pipeline) return 1; } // Validate state related to the PSO -static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VK_PIPELINE_BIND_POINT pipelineBindPoint, const VK_PIPELINE pipeline) +static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VkPipelineBindPoint pipelineBindPoint, const VkPipeline pipeline) { if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) { // Verify that any MSAA request in PSO matches sample# in bound FB uint32_t psoNumSamples = getNumSamples(pipeline); if (pCB->activeRenderPass) { - VK_RENDER_PASS_CREATE_INFO* pRPCI = renderPassMap[pCB->activeRenderPass]; - VK_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pCB->framebuffer]; + VkRenderPassCreateInfo* pRPCI = renderPassMap[pCB->activeRenderPass]; + VkFramebufferCreateInfo* pFBCI = frameBufferMap[pCB->framebuffer]; if (psoNumSamples != pFBCI->sampleCount) { char str[1024]; sprintf(str, "Num samples mismatche! Binding PSO (%p) with %u samples while current RenderPass (%p) uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, (void*)pCB->framebuffer, pFBCI->sampleCount); @@ -526,7 +526,7 @@ static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VK_PIPELINE_B // Block of code at start here specifically for managing/tracking DSs // Return Pool node ptr for specified pool or else NULL -static POOL_NODE* getPoolNode(VK_DESCRIPTOR_POOL pool) +static POOL_NODE* getPoolNode(VkDescriptorPool pool) { loader_platform_thread_lock_mutex(&globalLock); if (poolMap.find(pool) == poolMap.end()) { @@ -537,7 +537,7 @@ static POOL_NODE* getPoolNode(VK_DESCRIPTOR_POOL pool) return poolMap[pool]; } // Return Set node ptr for specified set or else NULL -static SET_NODE* getSetNode(VK_DESCRIPTOR_SET set) +static SET_NODE* getSetNode(VkDescriptorSet set) { loader_platform_thread_lock_mutex(&globalLock); if (setMap.find(set) == setMap.end()) { @@ -549,7 +549,7 @@ static SET_NODE* getSetNode(VK_DESCRIPTOR_SET set) } // Return VK_TRUE if DS Exists and is within an vkBeginDescriptorPoolUpdate() call sequence, otherwise VK_FALSE -static bool32_t dsUpdateActive(VK_DESCRIPTOR_SET ds) +static bool32_t dsUpdateActive(VkDescriptorSet ds) { // Note, both "get" functions use global mutex so this guy does not SET_NODE* pTrav = getSetNode(ds); @@ -562,7 +562,7 @@ static bool32_t dsUpdateActive(VK_DESCRIPTOR_SET ds) return VK_FALSE; } -static LAYOUT_NODE* getLayoutNode(const VK_DESCRIPTOR_SET_LAYOUT layout) { +static LAYOUT_NODE* getLayoutNode(const VkDescriptorSetLayout layout) { loader_platform_thread_lock_mutex(&globalLock); if (layoutMap.find(layout) == layoutMap.end()) { loader_platform_thread_unlock_mutex(&globalLock); @@ -578,15 +578,15 @@ static uint32_t getUpdateBinding(const GENERIC_HEADER* pUpdateStruct) switch (pUpdateStruct->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return ((VK_UPDATE_SAMPLERS*)pUpdateStruct)->binding; + return ((VkUpdateSamplers*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->binding; + return ((VkUpdateSamplerTextures*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - return ((VK_UPDATE_IMAGES*)pUpdateStruct)->binding; + return ((VkUpdateImages*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - return ((VK_UPDATE_BUFFERS*)pUpdateStruct)->binding; + return ((VkUpdateBuffers*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - return ((VK_UPDATE_AS_COPY*)pUpdateStruct)->binding; + return ((VkUpdateAsCopy*)pUpdateStruct)->binding; default: // TODO : Flag specific error for this case assert(0); @@ -599,16 +599,16 @@ static uint32_t getUpdateArrayIndex(const GENERIC_HEADER* pUpdateStruct) switch (pUpdateStruct->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->arrayIndex); + return (((VkUpdateSamplers*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->arrayIndex); + return (((VkUpdateSamplerTextures*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - return (((VK_UPDATE_IMAGES*)pUpdateStruct)->arrayIndex); + return (((VkUpdateImages*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->arrayIndex); + return (((VkUpdateBuffers*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: // TODO : Need to understand this case better and make sure code is correct - return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->arrayElement); + return (((VkUpdateAsCopy*)pUpdateStruct)->arrayElement); default: // TODO : Flag specific error for this case assert(0); @@ -621,16 +621,16 @@ static uint32_t getUpdateCount(const GENERIC_HEADER* pUpdateStruct) switch (pUpdateStruct->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->count); + return (((VkUpdateSamplers*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->count); + return (((VkUpdateSamplerTextures*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - return (((VK_UPDATE_IMAGES*)pUpdateStruct)->count); + return (((VkUpdateImages*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->count); + return (((VkUpdateBuffers*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: // TODO : Need to understand this case better and make sure code is correct - return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->count); + return (((VkUpdateAsCopy*)pUpdateStruct)->count); default: // TODO : Flag specific error for this case assert(0); @@ -669,7 +669,7 @@ static uint32_t getUpdateEndIndex(const LAYOUT_NODE* pLayout, const GENERIC_HEAD static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct) { // First get actual type of update - VK_DESCRIPTOR_TYPE actualType; + VkDescriptorType actualType; uint32_t i = 0; switch (pUpdateStruct->sType) { @@ -680,13 +680,13 @@ static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEA actualType = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE; break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - actualType = ((VK_UPDATE_IMAGES*)pUpdateStruct)->descriptorType; + actualType = ((VkUpdateImages*)pUpdateStruct)->descriptorType; break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - actualType = ((VK_UPDATE_BUFFERS*)pUpdateStruct)->descriptorType; + actualType = ((VkUpdateBuffers*)pUpdateStruct)->descriptorType; break; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - actualType = ((VK_UPDATE_AS_COPY*)pUpdateStruct)->descriptorType; + actualType = ((VkUpdateAsCopy*)pUpdateStruct)->descriptorType; break; default: // TODO : Flag specific error for this case @@ -704,64 +704,64 @@ static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEA static GENERIC_HEADER* shadowUpdateNode(GENERIC_HEADER* pUpdate) { GENERIC_HEADER* pNewNode = NULL; - VK_UPDATE_SAMPLERS* pUS = NULL; - VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL; - VK_UPDATE_BUFFERS* pUB = NULL; - VK_UPDATE_IMAGES* pUI = NULL; - VK_UPDATE_AS_COPY* pUAC = NULL; + VkUpdateSamplers* pUS = NULL; + VkUpdateSamplerTextures* pUST = NULL; + VkUpdateBuffers* pUB = NULL; + VkUpdateImages* pUI = NULL; + VkUpdateAsCopy* pUAC = NULL; size_t array_size = 0; size_t base_array_size = 0; size_t total_array_size = 0; size_t baseBuffAddr = 0; - VK_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = NULL; - VK_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = NULL; + VkImageViewAttachInfo** ppLocalImageViews = NULL; + VkBufferViewAttachInfo** ppLocalBufferViews = NULL; char str[1024]; switch (pUpdate->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - pUS = new VK_UPDATE_SAMPLERS; + pUS = new VkUpdateSamplers; pNewNode = (GENERIC_HEADER*)pUS; - memcpy(pUS, pUpdate, sizeof(VK_UPDATE_SAMPLERS)); - pUS->pSamplers = new VK_SAMPLER[pUS->count]; - array_size = sizeof(VK_SAMPLER) * pUS->count; - memcpy((void*)pUS->pSamplers, ((VK_UPDATE_SAMPLERS*)pUpdate)->pSamplers, array_size); + memcpy(pUS, pUpdate, sizeof(VkUpdateSamplers)); + pUS->pSamplers = new VkSampler[pUS->count]; + array_size = sizeof(VkSampler) * pUS->count; + memcpy((void*)pUS->pSamplers, ((VkUpdateSamplers*)pUpdate)->pSamplers, array_size); break; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - pUST = new VK_UPDATE_SAMPLER_TEXTURES; + pUST = new VkUpdateSamplerTextures; pNewNode = (GENERIC_HEADER*)pUST; - memcpy(pUST, pUpdate, sizeof(VK_UPDATE_SAMPLER_TEXTURES)); - pUST->pSamplerImageViews = new VK_SAMPLER_IMAGE_VIEW_INFO[pUST->count]; - array_size = sizeof(VK_SAMPLER_IMAGE_VIEW_INFO) * pUST->count; - memcpy((void*)pUST->pSamplerImageViews, ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews, array_size); + memcpy(pUST, pUpdate, sizeof(VkUpdateSamplerTextures)); + pUST->pSamplerImageViews = new VkSamplerImageViewInfo[pUST->count]; + array_size = sizeof(VkSamplerImageViewInfo) * pUST->count; + memcpy((void*)pUST->pSamplerImageViews, ((VkUpdateSamplerTextures*)pUpdate)->pSamplerImageViews, array_size); for (uint32_t i = 0; i < pUST->count; i++) { - VK_IMAGE_VIEW_ATTACH_INFO** ppIV = (VK_IMAGE_VIEW_ATTACH_INFO**)&pUST->pSamplerImageViews[i].pImageView; - *ppIV = new VK_IMAGE_VIEW_ATTACH_INFO; - memcpy((void*)*ppIV, ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(VK_IMAGE_VIEW_ATTACH_INFO)); + VkImageViewAttachInfo** ppIV = (VkImageViewAttachInfo**)&pUST->pSamplerImageViews[i].pImageView; + *ppIV = new VkImageViewAttachInfo; + memcpy((void*)*ppIV, ((VkUpdateSamplerTextures*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(VkImageViewAttachInfo)); } break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - pUI = new VK_UPDATE_IMAGES; + pUI = new VkUpdateImages; pNewNode = (GENERIC_HEADER*)pUI; - memcpy(pUI, pUpdate, sizeof(VK_UPDATE_IMAGES)); - pUI->pImageViews = new VK_IMAGE_VIEW_ATTACH_INFO[pUI->count]; - array_size = (sizeof(VK_IMAGE_VIEW_ATTACH_INFO) * pUI->count); - memcpy((void*)pUI->pImageViews, ((VK_UPDATE_IMAGES*)pUpdate)->pImageViews, array_size); + memcpy(pUI, pUpdate, sizeof(VkUpdateImages)); + pUI->pImageViews = new VkImageViewAttachInfo[pUI->count]; + array_size = (sizeof(VkImageViewAttachInfo) * pUI->count); + memcpy((void*)pUI->pImageViews, ((VkUpdateImages*)pUpdate)->pImageViews, array_size); break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - pUB = new VK_UPDATE_BUFFERS; + pUB = new VkUpdateBuffers; pNewNode = (GENERIC_HEADER*)pUB; - memcpy(pUB, pUpdate, sizeof(VK_UPDATE_BUFFERS)); - pUB->pBufferViews = new VK_BUFFER_VIEW_ATTACH_INFO[pUB->count]; - array_size = (sizeof(VK_BUFFER_VIEW_ATTACH_INFO) * pUB->count); - memcpy((void*)pUB->pBufferViews, ((VK_UPDATE_BUFFERS*)pUpdate)->pBufferViews, array_size); + memcpy(pUB, pUpdate, sizeof(VkUpdateBuffers)); + pUB->pBufferViews = new VkBufferViewAttachInfo[pUB->count]; + array_size = (sizeof(VkBufferViewAttachInfo) * pUB->count); + memcpy((void*)pUB->pBufferViews, ((VkUpdateBuffers*)pUpdate)->pBufferViews, array_size); break; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - pUAC = new VK_UPDATE_AS_COPY; + pUAC = new VkUpdateAsCopy; pUpdate = (GENERIC_HEADER*)pUAC; - memcpy(pUAC, pUpdate, sizeof(VK_UPDATE_AS_COPY)); + memcpy(pUAC, pUpdate, sizeof(VkUpdateAsCopy)); break; default: - sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VK_STRUCTURE_TYPE(pUpdate->sType), pUpdate->sType); + sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdate->sType), pUpdate->sType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str); return NULL; } @@ -770,13 +770,13 @@ static GENERIC_HEADER* shadowUpdateNode(GENERIC_HEADER* pUpdate) return pNewNode; } // For given ds, update its mapping based on ppUpdateArray -static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** ppUpdateArray) +static void dsUpdate(VkDescriptorSet ds, uint32_t updateCount, const void** ppUpdateArray) { SET_NODE* pSet = getSetNode(ds); loader_platform_thread_lock_mutex(&globalLock); g_lastBoundDescriptorSet = pSet->set; LAYOUT_NODE* pLayout = NULL; - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pLayoutCI = NULL; + VkDescriptorSetLayoutCreateInfo* pLayoutCI = NULL; // TODO : If pCIList is NULL, flag error // Perform all updates for (uint32_t i = 0; i < updateCount; i++) { @@ -785,7 +785,7 @@ static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** pp // Make sure that binding is within bounds if (pLayout->createInfo.count < getUpdateBinding(pUpdate)) { char str[1024]; - sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_VK_STRUCTURE_TYPE(pUpdate->sType)); + sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_VkStructureType(pUpdate->sType)); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", str); } else { @@ -793,15 +793,15 @@ static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** pp if (getBindingEndIndex(pLayout, getUpdateBinding(pUpdate)) < getUpdateEndIndex(pLayout, pUpdate)) { char str[48*1024]; // TODO : Keep count of layout CI structs and size this string dynamically based on that count pLayoutCI = &pLayout->createInfo; - string DSstr = vk_print_vk_descriptor_set_layout_create_info(pLayoutCI, "{DS} "); - sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VK_STRUCTURE_TYPE(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str()); + string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} "); + sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str()); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", str); } else { // TODO : should we skip update on a type mismatch or force it? // Layout bindings match w/ update ok, now verify that update is of the right type if (!validateUpdateType(pLayout, pUpdate)) { char str[1024]; - sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_VK_STRUCTURE_TYPE(pUpdate->sType)); + sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_VkStructureType(pUpdate->sType)); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", str); } else { @@ -843,20 +843,20 @@ static void freeShadowUpdateTree(SET_NODE* pSet) pFreeUpdate = pShadowUpdate; pShadowUpdate = (GENERIC_HEADER*)pShadowUpdate->pNext; uint32_t index = 0; - VK_UPDATE_SAMPLERS* pUS = NULL; - VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL; - VK_UPDATE_IMAGES* pUI = NULL; - VK_UPDATE_BUFFERS* pUB = NULL; + VkUpdateSamplers* pUS = NULL; + VkUpdateSamplerTextures* pUST = NULL; + VkUpdateImages* pUI = NULL; + VkUpdateBuffers* pUB = NULL; void** ppToFree = NULL; switch (pFreeUpdate->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - pUS = (VK_UPDATE_SAMPLERS*)pFreeUpdate; + pUS = (VkUpdateSamplers*)pFreeUpdate; if (pUS->pSamplers) delete[] pUS->pSamplers; break; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pFreeUpdate; + pUST = (VkUpdateSamplerTextures*)pFreeUpdate; if (pUST->pSamplerImageViews) { for (index = 0; index < pUST->count; index++) { if (pUST->pSamplerImageViews[index].pImageView) { @@ -867,12 +867,12 @@ static void freeShadowUpdateTree(SET_NODE* pSet) } break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - pUI = (VK_UPDATE_IMAGES*)pFreeUpdate; + pUI = (VkUpdateImages*)pFreeUpdate; if (pUI->pImageViews) delete[] pUI->pImageViews; break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - pUB = (VK_UPDATE_BUFFERS*)pFreeUpdate; + pUB = (VkUpdateBuffers*)pFreeUpdate; if (pUB->pBufferViews) delete[] pUB->pBufferViews; break; @@ -889,7 +889,7 @@ static void freeShadowUpdateTree(SET_NODE* pSet) // NOTE : Calls to this function should be wrapped in mutex static void deletePools() { - for (unordered_map::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) { + for (unordered_map::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) { SET_NODE* pSet = (*ii).second->pSets; SET_NODE* pFreeSet = pSet; while (pSet) { @@ -913,7 +913,7 @@ static void deletePools() // NOTE : Calls to this function should be wrapped in mutex static void deleteLayouts() { - for (unordered_map::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) { + for (unordered_map::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) { LAYOUT_NODE* pLayout = (*ii).second; if (pLayout->createInfo.pBinding) { for (uint32_t i=0; icreateInfo.count; i++) { @@ -930,7 +930,7 @@ static void deleteLayouts() } // Currently clearing a set is removing all previous updates to that set // TODO : Validate if this is correct clearing behavior -static void clearDescriptorSet(VK_DESCRIPTOR_SET set) +static void clearDescriptorSet(VkDescriptorSet set) { SET_NODE* pSet = getSetNode(set); if (!pSet) { @@ -943,7 +943,7 @@ static void clearDescriptorSet(VK_DESCRIPTOR_SET set) } } -static void clearDescriptorPool(VK_DESCRIPTOR_POOL pool) +static void clearDescriptorPool(VkDescriptorPool pool) { POOL_NODE* pPool = getPoolNode(pool); if (!pPool) { @@ -961,7 +961,7 @@ static void clearDescriptorPool(VK_DESCRIPTOR_POOL pool) } } // Code here to manage the Cmd buffer LL -static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb) +static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb) { loader_platform_thread_lock_mutex(&globalLock); if (cmdBufferMap.find(cb) == cmdBufferMap.end()) { @@ -975,7 +975,7 @@ static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb) // NOTE : Calls to this function should be wrapped in mutex static void deleteCmdBuffers() { - for (unordered_map::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) { + for (unordered_map::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) { while (!(*ii).second->pCmds.empty()) { delete (*ii).second->pCmds.back(); (*ii).second->pCmds.pop_back(); @@ -999,7 +999,7 @@ static void addCmd(GLOBAL_CB_NODE* pCB, const CMD_TYPE cmd) layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); } } -static void resetCB(const VK_CMD_BUFFER cb) +static void resetCB(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1008,7 +1008,7 @@ static void resetCB(const VK_CMD_BUFFER cb) pCB->pCmds.pop_back(); } // Reset CB state - VK_FLAGS saveFlags = pCB->flags; + VkFlags saveFlags = pCB->flags; uint32_t saveQueueNodeIndex = pCB->queueNodeIndex; memset(pCB, 0, sizeof(GLOBAL_CB_NODE)); pCB->cmdBuffer = cb; @@ -1019,7 +1019,7 @@ static void resetCB(const VK_CMD_BUFFER cb) } // Set the last bound dynamic state of given type // TODO : Need to track this per cmdBuffer and correlate cmdBuffer for Draw w/ last bound for that cmdBuffer? -static void setLastBoundDynamicState(const VK_CMD_BUFFER cmdBuffer, const VK_DYNAMIC_STATE_OBJECT state, const VK_STATE_BIND_POINT sType) +static void setLastBoundDynamicState(const VkCmdBuffer cmdBuffer, const VkDynamicStateObject state, const VkStateBindPoint sType) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1044,7 +1044,7 @@ static void setLastBoundDynamicState(const VK_CMD_BUFFER cmdBuffer, const VK_DYN } } // Print the last bound Gfx Pipeline -static void printPipeline(const VK_CMD_BUFFER cb) +static void printPipeline(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1053,13 +1053,13 @@ static void printPipeline(const VK_CMD_BUFFER cb) // nothing to print } else { - string pipeStr = vk_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str(); + string pipeStr = vk_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str(); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", pipeStr.c_str()); } } } // Common Dot dumping code -static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) +static void dsCoreDumpDot(const VkDescriptorSet ds, FILE* pOutFile) { SET_NODE* pSet = getSetNode(ds); if (pSet) { @@ -1067,7 +1067,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) char tmp_str[4*1024]; fprintf(pOutFile, "subgraph cluster_DescriptorPool\n{\nlabel=\"Descriptor Pool\"\n"); sprintf(tmp_str, "Pool (%p)", pPool->pool); - char* pGVstr = vk_gv_print_vk_descriptor_pool_create_info(&pPool->createInfo, tmp_str); + char* pGVstr = vk_gv_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, tmp_str); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); fprintf(pOutFile, "subgraph cluster_DescriptorSet\n{\nlabel=\"Descriptor Set (%p)\"\n", pSet->set); @@ -1076,7 +1076,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) uint32_t layout_index = 0; ++layout_index; sprintf(tmp_str, "LAYOUT%u", layout_index); - pGVstr = vk_gv_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, tmp_str); + pGVstr = vk_gv_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, tmp_str); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); if (pSet->pUpdateStructs) { @@ -1089,7 +1089,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) uint32_t i = 0; for (i=0; i < pSet->descriptorCount; i++) { if (pSet->ppDescriptors[i]) { - fprintf(pOutFile, "slot%u%s", i, i, string_VK_STRUCTURE_TYPE(pSet->ppDescriptors[i]->sType)); + fprintf(pOutFile, "slot%u%s", i, i, string_VkStructureType(pSet->ppDescriptors[i]->sType)); } } #define NUM_COLORS 7 @@ -1104,13 +1104,13 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) uint32_t colorIdx = 0; fprintf(pOutFile, ">\n];\n"); // Now add the views that are mapped to active descriptors - VK_UPDATE_SAMPLERS* pUS = NULL; - VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL; - VK_UPDATE_IMAGES* pUI = NULL; - VK_UPDATE_BUFFERS* pUB = NULL; - VK_UPDATE_AS_COPY* pUAC = NULL; - VK_SAMPLER_CREATE_INFO* pSCI = NULL; - VK_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL; + VkUpdateSamplers* pUS = NULL; + VkUpdateSamplerTextures* pUST = NULL; + VkUpdateImages* pUI = NULL; + VkUpdateBuffers* pUB = NULL; + VkUpdateAsCopy* pUAC = NULL; + VkSamplerCreateInfo* pSCI = NULL; + VkImageViewCreateInfo* pIVCI = NULL; VkBufferViewCreateInfo* pBVCI = NULL; void** ppNextPtr = NULL; void* pSaveNext = NULL; @@ -1119,40 +1119,40 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) switch (pSet->ppDescriptors[i]->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - pUS = (VK_UPDATE_SAMPLERS*)pSet->ppDescriptors[i]; + pUS = (VkUpdateSamplers*)pSet->ppDescriptors[i]; pSCI = getSamplerCreateInfo(pUS->pSamplers[i-pUS->arrayIndex]); if (pSCI) { sprintf(tmp_str, "SAMPLER%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vksamplercreateinfo(pSCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } break; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pSet->ppDescriptors[i]; + pUST = (VkUpdateSamplerTextures*)pSet->ppDescriptors[i]; pSCI = getSamplerCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].sampler); if (pSCI) { sprintf(tmp_str, "SAMPLER%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vksamplercreateinfo(pSCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } pIVCI = getImageViewCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].pImageView->view); if (pIVCI) { sprintf(tmp_str, "IMAGE_VIEW%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vkimageviewcreateinfo(pIVCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - pUI = (VK_UPDATE_IMAGES*)pSet->ppDescriptors[i]; + pUI = (VkUpdateImages*)pSet->ppDescriptors[i]; pIVCI = getImageViewCreateInfo(pUI->pImageViews[i-pUI->arrayIndex].view); if (pIVCI) { sprintf(tmp_str, "IMAGE_VIEW%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vkimageviewcreateinfo(pIVCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - pUB = (VK_UPDATE_BUFFERS*)pSet->ppDescriptors[i]; + pUB = (VkUpdateBuffers*)pSet->ppDescriptors[i]; pBVCI = getBufferViewCreateInfo(pUB->pBufferViews[i-pUB->arrayIndex].view); if (pBVCI) { sprintf(tmp_str, "BUFFER_VIEW%u", i); @@ -1161,14 +1161,14 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) } break; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - pUAC = (VK_UPDATE_AS_COPY*)pSet->ppDescriptors[i]; + pUAC = (VkUpdateAsCopy*)pSet->ppDescriptors[i]; // TODO : Need to validate this code // Save off pNext and set to NULL while printing this struct, then restore it ppNextPtr = (void**)&pUAC->pNext; pSaveNext = *ppNextPtr; *ppNextPtr = NULL; sprintf(tmp_str, "UPDATE_AS_COPY%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_update_as_copy(pUAC, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vkupdateascopy(pUAC, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); // Restore next ptr *ppNextPtr = pSaveNext; @@ -1185,7 +1185,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) } } // Dump subgraph w/ DS info -static void dsDumpDot(const VK_CMD_BUFFER cb, FILE* pOutFile) +static void dsDumpDot(const VkCmdBuffer cb, FILE* pOutFile) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB && pCB->lastBoundDescriptorSet) { @@ -1237,14 +1237,14 @@ static void dumpGlobalDotFile(char *outFileName) char* pGVstr = NULL; for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) { if (g_lastBoundDynamicState[i] && g_lastBoundDynamicState[i]->pCreateInfo) { - pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i)); + pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_VkStateBindPoint((VkStateBindPoint)i)); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); } } fprintf(pOutFile, "}\n"); // close dynamicState subgraph fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n"); - pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); + pGVstr = vk_gv_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); fprintf(pOutFile, "}\n"); @@ -1254,7 +1254,7 @@ static void dumpGlobalDotFile(char *outFileName) } } // Dump a GraphViz dot file showing the pipeline for a given CB -static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName) +static void dumpDotFile(const VkCmdBuffer cb, string outFileName) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1267,14 +1267,14 @@ static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName) char* pGVstr = NULL; for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) { if (pCB->lastBoundDynamicState[i] && pCB->lastBoundDynamicState[i]->pCreateInfo) { - pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i)); + pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_VkStateBindPoint((VkStateBindPoint)i)); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); } } fprintf(pOutFile, "}\n"); // close dynamicState subgraph fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n"); - pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); + pGVstr = vk_gv_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); fprintf(pOutFile, "}\n"); @@ -1285,7 +1285,7 @@ static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName) } } // Verify VB Buffer binding -static void validateVBBinding(const VK_CMD_BUFFER cb) +static void validateVBBinding(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB && pCB->lastBoundPipeline) { @@ -1310,7 +1310,7 @@ static void validateVBBinding(const VK_CMD_BUFFER cb) } } else { - string tmpStr = vk_print_vk_vertex_input_binding_description(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str(); + string tmpStr = vk_print_vkvertexinputbindingdescription(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str(); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmpStr.c_str()); } } @@ -1318,7 +1318,7 @@ static void validateVBBinding(const VK_CMD_BUFFER cb) } } // Print details of DS config to stdout -static void printDSConfig(const VK_CMD_BUFFER cb) +static void printDSConfig(const VkCmdBuffer cb) { char tmp_str[1024]; char ds_config_str[1024*256] = {0}; // TODO : Currently making this buffer HUGE w/o overrun protection. Need to be smarter, start smaller, and grow as needed. @@ -1329,7 +1329,7 @@ static void printDSConfig(const VK_CMD_BUFFER cb) // Print out pool details sprintf(tmp_str, "Details for pool %p.", (void*)pPool->pool); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str); - string poolStr = vk_print_vk_descriptor_pool_create_info(&pPool->createInfo, " "); + string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " "); sprintf(ds_config_str, "%s", poolStr.c_str()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str); // Print out set details @@ -1342,7 +1342,7 @@ static void printDSConfig(const VK_CMD_BUFFER cb) sprintf(tmp_str, "Layout #%u, (object %p) for DS %p.", index+1, (void*)pLayout->layout, (void*)pSet->set); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str); sprintf(prefix, " [L%u] ", index); - string DSLstr = vk_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, prefix).c_str(); + string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str(); sprintf(ds_config_str, "%s", DSLstr.c_str()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str); index++; @@ -1362,7 +1362,7 @@ static void printDSConfig(const VK_CMD_BUFFER cb) } } -static void printCB(const VK_CMD_BUFFER cb) +static void printCB(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1380,7 +1380,7 @@ static void printCB(const VK_CMD_BUFFER cb) } -static void synchAndPrintDSConfig(const VK_CMD_BUFFER cb) +static void synchAndPrintDSConfig(const VkCmdBuffer cb) { printDSConfig(cb); printPipeline(cb); @@ -1420,13 +1420,13 @@ static void initDrawState(void) } // initialize Layer dispatch table // TODO handle multiple GPUs - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); - vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr"); + PFN_vkGetProcAddr fpGetProcAddr = (PFN_vkGetProcAddr)fpNextGPA((VkPhysicalGpu) pCurObj->nextObject, (char *) "vkGetProcAddr"); nextTable.GetProcAddr = fpGetProcAddr; if (!globalLockInitialized) @@ -1441,16 +1441,16 @@ static void initDrawState(void) } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initDrawState); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { // Free all the memory loader_platform_thread_lock_mutex(&globalLock); @@ -1463,14 +1463,14 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) deletePools(); deleteLayouts(); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; - VK_RESULT result; + VkResult result; /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */ if (!strcmp(pExtName, "DrawState") || !strcmp(pExtName, "drawStateDumpDotFile") || !strcmp(pExtName, "drawStateDumpCommandBufferDotFile") || !strcmp(pExtName, "drawStateDumpPngFile")) @@ -1478,7 +1478,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const result = VK_SUCCESS; } else if (nextTable.GetExtensionSupport != NULL) { - result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else { result = VK_ERROR_INVALID_EXTENSION; @@ -1486,14 +1486,14 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initDrawState); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else { @@ -1506,25 +1506,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) { for (uint32_t i=0; i < cmdBufferCount; i++) { // Validate that cmd buffers have been updated } - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { // TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(object); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); BUFFER_NODE* pNewNode = new BUFFER_NODE; @@ -1536,9 +1536,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); IMAGE_NODE *pNewNode = new IMAGE_NODE; @@ -1550,7 +1550,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMA return result; } -static void track_pipeline(const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +static void track_pipeline(const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { // Create LL HEAD for this Pipeline loader_platform_thread_lock_mutex(&globalLock); @@ -1561,9 +1561,9 @@ static void track_pipeline(const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, loader_platform_thread_unlock_mutex(&globalLock); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); // Create LL HEAD for this Pipeline char str[1024]; sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline); @@ -1574,13 +1574,13 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline basePipeline, + VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); + VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); // Create LL HEAD for this Pipeline char str[1024]; sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline); @@ -1591,9 +1591,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( loader_platform_thread_unlock_mutex(&globalLock); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); SAMPLER_NODE* pNewNode = new SAMPLER_NODE; @@ -1605,9 +1605,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPL return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { - VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); if (VK_SUCCESS == result) { LAYOUT_NODE* pNewNode = new LAYOUT_NODE; if (NULL == pNewNode) { @@ -1616,20 +1616,20 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, co layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); } memset(pNewNode, 0, sizeof(LAYOUT_NODE)); - memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)); - pNewNode->createInfo.pBinding = new VK_DESCRIPTOR_SET_LAYOUT_BINDING[pCreateInfo->count]; - memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VK_DESCRIPTOR_SET_LAYOUT_BINDING)*pCreateInfo->count); + memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VkDescriptorSetLayoutCreateInfo)); + pNewNode->createInfo.pBinding = new VkDescriptorSetLayoutBinding[pCreateInfo->count]; + memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VkDescriptorSetLayoutBinding)*pCreateInfo->count); uint32_t totalCount = 0; for (uint32_t i=0; icount; i++) { totalCount += pCreateInfo->pBinding[i].count; if (pCreateInfo->pBinding[i].pImmutableSamplers) { - VK_SAMPLER** ppIS = (VK_SAMPLER**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers; - *ppIS = new VK_SAMPLER[pCreateInfo->pBinding[i].count]; - memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(VK_SAMPLER)); + VkSampler** ppIS = (VkSampler**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers; + *ppIS = new VkSampler[pCreateInfo->pBinding[i].count]; + memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(VkSampler)); } } if (totalCount > 0) { - pNewNode->pTypes = new VK_DESCRIPTOR_TYPE[totalCount]; + pNewNode->pTypes = new VkDescriptorType[totalCount]; uint32_t offset = 0; uint32_t j = 0; for (uint32_t i=0; icount; i++) { @@ -1651,18 +1651,18 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, co return result; } -VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain) +VkResult VKAPI vkCreateDescriptorSetLayoutChain(VkDevice device, uint32_t setLayoutArrayCount, const VkDescriptorSetLayout* pSetLayoutArray, VkDescriptorSetLayoutChain* pLayoutChain) { - VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); + VkResult result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); if (VK_SUCCESS == result) { // TODO : Need to capture the layout chains } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode) +VK_LAYER_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate(VkDevice device, VkDescriptorUpdateMode updateMode) { - VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); + VkResult result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); POOL_NODE* pPoolNode = poolMap.begin()->second; @@ -1679,9 +1679,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd) +VK_LAYER_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate(VkDevice device, VkCmdBuffer cmd) { - VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd); + VkResult result = nextTable.EndDescriptorPoolUpdate(device, cmd); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); POOL_NODE* pPoolNode = poolMap.begin()->second; @@ -1706,28 +1706,28 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { - VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); if (VK_SUCCESS == result) { // 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, (VK_BASE_OBJECT)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str); + layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkBaseObject)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, (VK_BASE_OBJECT)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); + layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VkBaseObject)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); } else { memset(pNewNode, 0, sizeof(POOL_NODE)); - VK_DESCRIPTOR_POOL_CREATE_INFO* pCI = (VK_DESCRIPTOR_POOL_CREATE_INFO*)&pNewNode->createInfo; - memcpy((void*)pCI, pCreateInfo, sizeof(VK_DESCRIPTOR_POOL_CREATE_INFO)); + VkDescriptorPoolCreateInfo* pCI = (VkDescriptorPoolCreateInfo*)&pNewNode->createInfo; + memcpy((void*)pCI, pCreateInfo, sizeof(VkDescriptorPoolCreateInfo)); if (pNewNode->createInfo.count) { - size_t typeCountSize = pNewNode->createInfo.count * sizeof(VK_DESCRIPTOR_TYPE_COUNT); - pNewNode->createInfo.pTypeCount = new VK_DESCRIPTOR_TYPE_COUNT[typeCountSize]; + size_t typeCountSize = pNewNode->createInfo.count * sizeof(VkDescriptorTypeCount); + pNewNode->createInfo.pTypeCount = new VkDescriptorTypeCount[typeCountSize]; memcpy((void*)pNewNode->createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize); } pNewNode->poolUsage = poolUsage; @@ -1744,18 +1744,18 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) { - VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(descriptorPool); if (VK_SUCCESS == result) { clearDescriptorPool(descriptorPool); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { - VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); if ((VK_SUCCESS == result) || (*pCount > 0)) { POOL_NODE *pPoolNode = getPoolNode(descriptorPool); if (!pPoolNode) { @@ -1804,7 +1804,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descrip return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { for (uint32_t i = 0; i < count; i++) { clearDescriptorSet(pDescriptorSets[i]); @@ -1812,7 +1812,7 @@ VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPo nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { SET_NODE* pSet = getSetNode(descriptorSet); if (!dsUpdateActive(descriptorSet)) { @@ -1828,37 +1828,37 @@ VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_VIEWPORT); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_RASTER); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_COLOR_BLEND); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_DEPTH_STENCIL); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE; @@ -1874,9 +1874,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); if (VK_SUCCESS == result) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1884,7 +1884,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co resetCB(cmdBuffer); pCB->state = CB_UPDATE_ACTIVE; if (pBeginInfo->pNext) { - VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pCbGfxBI = (VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pBeginInfo->pNext; + VkCmdBufferGraphicsBeginInfo* pCbGfxBI = (VkCmdBufferGraphicsBeginInfo*)pBeginInfo->pNext; if (VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) { pCB->activeRenderPass = pCbGfxBI->renderPassContinue.renderPass; } @@ -1900,9 +1900,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); if (VK_SUCCESS == result) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1920,9 +1920,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); if (VK_SUCCESS == result) { resetCB(cmdBuffer); updateCBTracking(cmdBuffer); @@ -1930,7 +1930,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1958,13 +1958,13 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { setLastBoundDynamicState(cmdBuffer, state, stateBindPoint); nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData) +VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1985,7 +1985,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P g_lastBoundDescriptorSet = pDescriptorSets[i]; loader_platform_thread_unlock_mutex(&globalLock); char str[1024]; - sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VK_PIPELINE_BIND_POINT(pipelineBindPoint)); + sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str); synchAndPrintDSConfig(cmdBuffer); } @@ -2004,7 +2004,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2020,7 +2020,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFF nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2037,7 +2037,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2057,7 +2057,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVert nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2077,7 +2077,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t fi nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2097,7 +2097,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2117,7 +2117,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_ nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z) +VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2132,7 +2132,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, ui nextTable.CmdDispatch(cmdBuffer, x, y, z); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2147,7 +2147,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2162,12 +2162,12 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2182,10 +2182,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_BLIT* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageBlit* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2200,10 +2200,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2218,10 +2218,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkBuffer destBuffer, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2236,7 +2236,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2251,7 +2251,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2266,7 +2266,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2281,10 +2281,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER de nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, + VkClearColor color, + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2299,10 +2299,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2317,10 +2317,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t rectCount, const VkImageResolve* pRects) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2335,7 +2335,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2350,7 +2350,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2365,7 +2365,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT eve nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo) +VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2380,7 +2380,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVE nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); } -VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier) +VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2395,7 +2395,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2410,7 +2410,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POO nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2425,7 +2425,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2440,7 +2440,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2455,7 +2455,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMES nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2470,7 +2470,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset) +VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2485,7 +2485,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2500,49 +2500,49 @@ VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { - VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); if (VK_SUCCESS == result) { // Shadow create info and store in map - VK_FRAMEBUFFER_CREATE_INFO* localFBCI = new VK_FRAMEBUFFER_CREATE_INFO(*pCreateInfo); + VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo); if (pCreateInfo->pColorAttachments) { - localFBCI->pColorAttachments = new VK_COLOR_ATTACHMENT_BIND_INFO[localFBCI->colorAttachmentCount]; - memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VK_COLOR_ATTACHMENT_BIND_INFO)); + localFBCI->pColorAttachments = new VkColorAttachmentBindInfo[localFBCI->colorAttachmentCount]; + memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VkColorAttachmentBindInfo)); } if (pCreateInfo->pDepthStencilAttachment) { - localFBCI->pDepthStencilAttachment = new VK_DEPTH_STENCIL_BIND_INFO[localFBCI->colorAttachmentCount]; - memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VK_DEPTH_STENCIL_BIND_INFO)); + localFBCI->pDepthStencilAttachment = new VkDepthStencilBindInfo[localFBCI->colorAttachmentCount]; + memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VkDepthStencilBindInfo)); } frameBufferMap[*pFramebuffer] = localFBCI; } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass) +VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { - VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); if (VK_SUCCESS == result) { // Shadow create info and store in map - VK_RENDER_PASS_CREATE_INFO* localRPCI = new VK_RENDER_PASS_CREATE_INFO(*pCreateInfo); + VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo); if (pCreateInfo->pColorLoadOps) { - localRPCI->pColorLoadOps = new VK_ATTACHMENT_LOAD_OP[localRPCI->colorAttachmentCount]; - memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_LOAD_OP)); + localRPCI->pColorLoadOps = new VkAttachmentLoadOp[localRPCI->colorAttachmentCount]; + memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentLoadOp)); } if (pCreateInfo->pColorStoreOps) { - localRPCI->pColorStoreOps = new VK_ATTACHMENT_STORE_OP[localRPCI->colorAttachmentCount]; - memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_STORE_OP)); + localRPCI->pColorStoreOps = new VkAttachmentStoreOp[localRPCI->colorAttachmentCount]; + memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentStoreOp)); } if (pCreateInfo->pColorLoadClearValues) { - localRPCI->pColorLoadClearValues = new VK_CLEAR_COLOR[localRPCI->colorAttachmentCount]; - memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VK_CLEAR_COLOR)); + localRPCI->pColorLoadClearValues = new VkClearColor[localRPCI->colorAttachmentCount]; + memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VkClearColor)); } renderPassMap[*pRenderPass] = localRPCI; } return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin) +VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin *pRenderPassBegin) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2561,7 +2561,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); } -VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass) +VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2577,7 +2577,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER nextTable.CmdEndRenderPass(cmdBuffer, renderPass); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = new VK_LAYER_DBG_FUNCTION_NODE; @@ -2591,11 +2591,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav; @@ -2617,11 +2617,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, else g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK)); } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2636,7 +2636,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const ch nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker); } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2688,7 +2688,7 @@ void drawStateDumpPngFile(char* outFileName) #endif // WIN32 } -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -2844,6 +2844,6 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } diff --git a/layers/draw_state.h b/layers/draw_state.h index 426bf38a..f1404724 100644 --- a/layers/draw_state.h +++ b/layers/draw_state.h @@ -65,84 +65,84 @@ typedef enum _DRAW_TYPE typedef struct _SHADER_DS_MAPPING { uint32_t slotCount; - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pShaderMappingSlot; + VkDescriptorSetLayoutCreateInfo* pShaderMappingSlot; } SHADER_DS_MAPPING; typedef struct _GENERIC_HEADER { - VK_STRUCTURE_TYPE sType; + VkStructureType sType; const void* pNext; } GENERIC_HEADER; typedef struct _PIPELINE_NODE { - VK_PIPELINE pipeline; - - VK_GRAPHICS_PIPELINE_CREATE_INFO graphicsPipelineCI; - VK_PIPELINE_VERTEX_INPUT_CREATE_INFO vertexInputCI; - VK_PIPELINE_IA_STATE_CREATE_INFO iaStateCI; - VK_PIPELINE_TESS_STATE_CREATE_INFO tessStateCI; - VK_PIPELINE_VP_STATE_CREATE_INFO vpStateCI; - VK_PIPELINE_RS_STATE_CREATE_INFO rsStateCI; - VK_PIPELINE_MS_STATE_CREATE_INFO msStateCI; - VK_PIPELINE_CB_STATE_CREATE_INFO cbStateCI; - VK_PIPELINE_DS_STATE_CREATE_INFO dsStateCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO vsCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO tcsCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO tesCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO gsCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO fsCI; - // Compute shader is include in VK_COMPUTE_PIPELINE_CREATE_INFO - VK_COMPUTE_PIPELINE_CREATE_INFO computePipelineCI; - - VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateTree; // Ptr to shadow of data in create tree + VkPipeline pipeline; + + VkGraphicsPipelineCreateInfo graphicsPipelineCI; + VkPipelineVertexInputCreateInfo vertexInputCI; + VkPipelineIaStateCreateInfo iaStateCI; + VkPipelineTessStateCreateInfo tessStateCI; + VkPipelineVpStateCreateInfo vpStateCI; + VkPipelineRsStateCreateInfo rsStateCI; + VkPipelineMsStateCreateInfo msStateCI; + VkPipelineCbStateCreateInfo cbStateCI; + VkPipelineDsStateCreateInfo dsStateCI; + VkPipelineShaderStageCreateInfo vsCI; + VkPipelineShaderStageCreateInfo tcsCI; + VkPipelineShaderStageCreateInfo tesCI; + VkPipelineShaderStageCreateInfo gsCI; + VkPipelineShaderStageCreateInfo fsCI; + // Compute shader is include in VkComputePipelineCreateInfo + VkComputePipelineCreateInfo computePipelineCI; + + VkGraphicsPipelineCreateInfo* pCreateTree; // Ptr to shadow of data in create tree // Vtx input info (if any) uint32_t vtxBindingCount; // number of bindings - VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; + VkVertexInputBindingDescription* pVertexBindingDescriptions; uint32_t vtxAttributeCount; // number of attributes - VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; + VkVertexInputAttributeDescription* pVertexAttributeDescriptions; uint32_t attachmentCount; // number of CB attachments - VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; + VkPipelineCbAttachmentState* pAttachments; } PIPELINE_NODE; typedef struct _SAMPLER_NODE { - VK_SAMPLER sampler; - VK_SAMPLER_CREATE_INFO createInfo; + VkSampler sampler; + VkSamplerCreateInfo createInfo; } SAMPLER_NODE; typedef struct _IMAGE_NODE { - VK_IMAGE_VIEW image; - VK_IMAGE_VIEW_CREATE_INFO createInfo; - VK_IMAGE_VIEW_ATTACH_INFO attachInfo; + VkImageView image; + VkImageViewCreateInfo createInfo; + VkImageViewAttachInfo attachInfo; } IMAGE_NODE; typedef struct _BUFFER_NODE { - VK_BUFFER_VIEW buffer; + VkBufferView buffer; VkBufferViewCreateInfo createInfo; - VK_BUFFER_VIEW_ATTACH_INFO attachInfo; + VkBufferViewAttachInfo attachInfo; } BUFFER_NODE; typedef struct _DYNAMIC_STATE_NODE { - VK_DYNAMIC_STATE_OBJECT stateObj; + VkDynamicStateObject stateObj; GENERIC_HEADER* pCreateInfo; union { - VK_DYNAMIC_VP_STATE_CREATE_INFO vpci; - VK_DYNAMIC_RS_STATE_CREATE_INFO rsci; - VK_DYNAMIC_CB_STATE_CREATE_INFO cbci; - VK_DYNAMIC_DS_STATE_CREATE_INFO dsci; + VkDynamicVpStateCreateInfo vpci; + VkDynamicRsStateCreateInfo rsci; + VkDynamicCbStateCreateInfo cbci; + VkDynamicDsStateCreateInfo dsci; } create_info; } DYNAMIC_STATE_NODE; // Descriptor Data structures // Layout Node has the core layout data typedef struct _LAYOUT_NODE { - VK_DESCRIPTOR_SET_LAYOUT layout; - VK_DESCRIPTOR_TYPE* pTypes; // Dynamic array that will be created to verify descriptor types - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO createInfo; + VkDescriptorSetLayout layout; + VkDescriptorType* pTypes; // Dynamic array that will be created to verify descriptor types + VkDescriptorSetLayoutCreateInfo createInfo; uint32_t startIndex; // 1st index of this layout uint32_t endIndex; // last index of this layout } LAYOUT_NODE; typedef struct _SET_NODE { - VK_DESCRIPTOR_SET set; - VK_DESCRIPTOR_POOL pool; - VK_DESCRIPTOR_SET_USAGE setUsage; + VkDescriptorSet set; + VkDescriptorPool pool; + VkDescriptorSetUsage setUsage; // Head of LL of all Update structs for this set GENERIC_HEADER* pUpdateStructs; // Total num of descriptors in this set (count of its layout plus all prior layouts) @@ -153,10 +153,10 @@ typedef struct _SET_NODE { } SET_NODE; typedef struct _POOL_NODE { - VK_DESCRIPTOR_POOL pool; - VK_DESCRIPTOR_POOL_USAGE poolUsage; + VkDescriptorPool pool; + VkDescriptorPoolUsage poolUsage; uint32_t maxSets; - VK_DESCRIPTOR_POOL_CREATE_INFO createInfo; + VkDescriptorPoolCreateInfo createInfo; bool32_t updateActive; // Track if Pool is in an update block SET_NODE* pSets; // Head of LL of sets for this Pool } POOL_NODE; @@ -218,10 +218,10 @@ typedef enum _CB_STATE } CB_STATE; // Cmd Buffer Wrapper Struct typedef struct _GLOBAL_CB_NODE { - VK_CMD_BUFFER cmdBuffer; + VkCmdBuffer cmdBuffer; uint32_t queueNodeIndex; - VK_FLAGS flags; - VK_FENCE fence; // fence tracking this cmd buffer + VkFlags flags; + VkFence fence; // fence tracking this cmd buffer uint64_t numCmds; // number of cmds in this CB uint64_t drawCount[NUM_DRAW_TYPES]; // Count of each type of draw in this CB CB_STATE state; // Track if cmd buffer update status @@ -229,12 +229,12 @@ typedef struct _GLOBAL_CB_NODE { // Currently storing "lastBound" objects on per-CB basis // long-term may want to create caches of "lastBound" states and could have // each individual CMD_NODE referencing its own "lastBound" state - VK_PIPELINE lastBoundPipeline; + VkPipeline lastBoundPipeline; uint32_t lastVtxBinding; DYNAMIC_STATE_NODE* lastBoundDynamicState[VK_NUM_STATE_BIND_POINT]; - VK_DESCRIPTOR_SET lastBoundDescriptorSet; - VK_RENDER_PASS activeRenderPass; - VK_FRAMEBUFFER framebuffer; + VkDescriptorSet lastBoundDescriptorSet; + VkRenderPass activeRenderPass; + VkFramebuffer framebuffer; } GLOBAL_CB_NODE; //prototypes for extension functions diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c index b4a976e8..5180ed70 100644 --- a/layers/glave_snapshot.c +++ b/layers/glave_snapshot.c @@ -139,19 +139,19 @@ void glv_deepfree_VkDeviceCreateInfo(VkDeviceCreateInfo* pCreateInfo) free(pCreateInfo); } -void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { pDest->gpu = gpu; pDest->pCreateInfo = glv_deepcopy_VkDeviceCreateInfo(pCreateInfo); - pDest->pDevice = (VK_DEVICE*)malloc(sizeof(VK_DEVICE)); + pDest->pDevice = (VkDevice*)malloc(sizeof(VkDevice)); *pDest->pDevice = *pDevice; } void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc) { - memset(&pSrc->gpu, 0, sizeof(VK_PHYSICAL_GPU)); + memset(&pSrc->gpu, 0, sizeof(VkPhysicalGpu)); glv_deepfree_VkDeviceCreateInfo(pSrc->pCreateInfo); pSrc->pCreateInfo = NULL; @@ -267,7 +267,7 @@ static void snapshot_insert_deleted_object(GLV_VK_SNAPSHOT* pSnapshot, void* pOb } // Note: the parameters after pSnapshot match the order of vkCreateDevice(..) -static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, VK_OBJECT_TYPE_DEVICE); pNode->obj.pStruct = malloc(sizeof(GLV_VK_SNAPSHOT_DEVICE_NODE)); @@ -283,7 +283,7 @@ static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU g pSnapshot->deviceCount++; } -static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VK_DEVICE device) +static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VkDevice device) { GLV_VK_SNAPSHOT_LL_NODE* pFoundObject = snapshot_remove_object(pSnapshot, device); @@ -331,7 +331,7 @@ static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VK_DEVICE device) } // Traverse global list and return type for given object -static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) { +static VK_OBJECT_TYPE ll_get_obj_type(VkObject object) { GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs; while (pTrav) { if (pTrav->obj.pVkObject == object) @@ -386,7 +386,7 @@ static void set_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_ } // Track selected state for an object node -static void track_object_status(void* pObj, VK_STATE_BIND_POINT stateBindPoint) { +static void track_object_status(void* pObj, VkStateBindPoint stateBindPoint) { GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[VK_OBJECT_TYPE_CMD_BUFFER]; while (pTrav) { @@ -447,11 +447,11 @@ static void initGlaveSnapshot(void) g_logFile = stdout; } - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); if (!objLockInitialized) { // TODO/TBD: Need to delete this mutex sometime. How??? @@ -463,48 +463,48 @@ static void initGlaveSnapshot(void) //============================================================================= // vulkan entrypoints //============================================================================= -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance) +VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) { - VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance); + VkResult result = nextTable.CreateInstance(pCreateInfo, pInstance); loader_platform_thread_lock_mutex(&objLock); snapshot_insert_object(&s_delta, *pInstance, VK_OBJECT_TYPE_INSTANCE); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance) { - VK_RESULT result = nextTable.DestroyInstance(instance); + VkResult result = nextTable.DestroyInstance(instance); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_object(&s_delta, (void*)instance); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateGpus(VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, VkPhysicalGpu* pGpus) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)instance, VK_OBJECT_TYPE_INSTANCE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); + VkResult result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData); + VkResult result = nextTable.GetGpuInfo((VkPhysicalGpu)gpuw->nextObject, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -514,9 +514,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDevi return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_device(&s_delta, device); loader_platform_thread_unlock_mutex(&objLock); @@ -541,7 +541,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; loader_platform_thread_lock_mutex(&objLock); @@ -549,11 +549,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + VkResult result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -562,7 +562,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else { if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL) @@ -574,43 +574,43 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue) +VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) { set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED); - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) { - VK_RESULT result = nextTable.QueueWaitIdle(queue); + VkResult result = nextTable.QueueWaitIdle(queue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DeviceWaitIdle(device); + VkResult result = nextTable.DeviceWaitIdle(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem); + VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -621,54 +621,54 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAl return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkGpuMemory mem) { - VK_RESULT result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(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 VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(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); - VK_RESULT result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(mem, priority); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(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); - VK_RESULT result = nextTable.MapMemory(mem, flags, ppData); + VkResult result = nextTable.MapMemory(mem, flags, ppData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(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); - VK_RESULT result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); + VkResult result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo) +VK_LAYER_EXPORT VkResult VKAPI vkGetMultiGpuCompatibility(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0; loader_platform_thread_lock_mutex(&objLock); @@ -676,97 +676,97 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo); + VkResult result = nextTable.GetMultiGpuCompatibility((VkPhysicalGpu)gpuw->nextObject, gpu1, pInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedSemaphore(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); + VkResult result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); + VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(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 VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject 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); - VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(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); - VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); + VkResult result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(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); - VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); + VkResult result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindImageMemoryRange(VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* bindInfo, VkGpuMemory mem, VkGpuSize memOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); + VkResult result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence); + VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -777,31 +777,31 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(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 - VK_RESULT result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout) +VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); + VkResult result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); + VkResult result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -812,24 +812,24 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEM return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore); + VkResult result = nextTable.QueueSignalSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore); + VkResult result = nextTable.QueueWaitSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent) +VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent); + VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -840,39 +840,39 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetEventStatus(event); + VkResult result = nextTable.GetEventStatus(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.SetEvent(event); + VkResult result = nextTable.SetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.ResetEvent(event); + VkResult result = nextTable.ResetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); + VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -883,30 +883,30 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUE return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(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); - VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); + VkResult result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); + VkResult result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); + VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -917,12 +917,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -933,12 +933,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage); + VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -949,21 +949,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(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); - VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); + VkResult result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -974,12 +974,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMA return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -990,12 +990,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, co return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1006,12 +1006,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader) +VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader); + VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1022,12 +1022,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1038,12 +1038,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1054,30 +1054,30 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(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); - VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData); + VkResult result = nextTable.StorePipeline(pipeline, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); + VkResult result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1088,12 +1088,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPL return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1104,30 +1104,30 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( VK_DEVICE device, c return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode) +VK_LAYER_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate(VkDevice device, VkDescriptorUpdateMode updateMode) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); + VkResult result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd) +VK_LAYER_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate(VkDevice device, VkCmdBuffer cmd) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd); + VkResult result = nextTable.EndDescriptorPoolUpdate(device, cmd); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1138,21 +1138,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(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); - VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(descriptorPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(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); - VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); if (result == VK_SUCCESS) { for (uint32_t i = 0; i < *pCount; i++) { @@ -1165,7 +1165,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descrip return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(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); @@ -1173,7 +1173,7 @@ VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPo nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(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); @@ -1181,12 +1181,12 @@ VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1197,12 +1197,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, c return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1213,12 +1213,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, con return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1229,12 +1229,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1245,12 +1245,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE devic return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1261,16 +1261,16 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1279,20 +1279,20 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) OBJSTATUS_RASTER_BOUND | OBJSTATUS_COLOR_BLEND_BOUND | OBJSTATUS_DEPTH_STENCIL_BOUND)); - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1300,7 +1300,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1309,7 +1309,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData) +VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1317,7 +1317,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1325,7 +1325,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1333,7 +1333,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFF nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1341,7 +1341,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVert nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1349,7 +1349,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t fi nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1357,7 +1357,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1365,7 +1365,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_ nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z) +VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1373,7 +1373,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, ui nextTable.CmdDispatch(cmdBuffer, x, y, z); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1381,7 +1381,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1389,7 +1389,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1397,7 +1397,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcI nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1405,7 +1405,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BU nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1413,7 +1413,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1421,7 +1421,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1429,7 +1429,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1437,7 +1437,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER de nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1445,7 +1445,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAG nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1453,7 +1453,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t rectCount, const VkImageResolve* pRects) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1461,7 +1461,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE s nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1469,7 +1469,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1477,7 +1477,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT eve nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo) +VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1485,7 +1485,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVE nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); } -VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier) +VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1493,7 +1493,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1501,7 +1501,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POO nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1509,7 +1509,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1517,7 +1517,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1525,7 +1525,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMES nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1533,7 +1533,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset) +VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1541,7 +1541,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1549,12 +1549,12 @@ VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1565,12 +1565,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_F return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass) +VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1581,7 +1581,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RE return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin) +VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin *pRenderPassBegin) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1589,7 +1589,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); } -VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass) +VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1597,16 +1597,16 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER nextTable.CmdEndRenderPass(cmdBuffer, renderPass); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetValidationLevel(VkDevice device, VkValidationLevel validationLevel) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel); + VkResult result = nextTable.DbgSetValidationLevel(device, validationLevel); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE)); @@ -1619,11 +1619,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V // force callbacks if DebugAction hasn't been set already other than initial value if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; - } VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + } VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav; @@ -1645,44 +1645,44 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, else g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter); + VkResult result = nextTable.DbgSetMessageFilter(device, msgCode, filter); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkBaseObject object, size_t tagSize, const void* pTag) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag); + VkResult result = nextTable.DbgSetObjectTag(object, tagSize, pTag); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetGlobalOption(VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) { - VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetDeviceOption(VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1690,7 +1690,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const ch nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker); } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1700,7 +1700,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) #if defined(__linux__) || defined(XCB_NVIDIA) -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; loader_platform_thread_lock_mutex(&objLock); @@ -1708,25 +1708,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo); + VkResult result = nextTable.WsiX11AssociateConnection((VkPhysicalGpu)gpuw->nextObject, pConnectionInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11GetMSC(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); + VkResult result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); + VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); if (result == VK_SUCCESS) { @@ -1743,9 +1743,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence) { - VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); + VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); return result; } @@ -1858,7 +1858,7 @@ uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type) return retVal; } -VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray) +VkResult glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray) { // This bool flags if we're pulling all objs or just a single class of objs bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY); @@ -1892,7 +1892,7 @@ void glvSnapshotPrintObjects(void) } #include "vk_generic_intercept_proc_helper.h" -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; void* addr; @@ -1927,7 +1927,7 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h index f22915cc..f0de0e91 100644 --- a/layers/glave_snapshot.h +++ b/layers/glave_snapshot.h @@ -173,13 +173,13 @@ void glv_vk_malloc_and_copy(void** ppDest, size_t size, const void* pSrc); typedef struct _GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS { - VK_PHYSICAL_GPU gpu; + VkPhysicalGpu gpu; VkDeviceCreateInfo* pCreateInfo; - VK_DEVICE* pDevice; + VkDevice* pDevice; } GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS; VkDeviceCreateInfo* glv_deepcopy_xgl_device_create_info(const VkDeviceCreateInfo* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VkDeviceCreateInfo* pCreateInfo); -void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice); +void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc); //============================================================================= @@ -195,10 +195,10 @@ typedef struct _GLV_VK_SNAPSHOT_OBJECT_NODE { void* pStruct; //< optionally points to a device-specific struct (ie, GLV_VK_SNAPSHOT_DEVICE_NODE) } GLV_VK_SNAPSHOT_OBJECT_NODE; -// Node that stores information about an VK_DEVICE +// Node that stores information about an VkDevice typedef struct _GLV_VK_SNAPSHOT_DEVICE_NODE { // This object - VK_DEVICE device; + VkDevice device; // CreateDevice parameters GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS params; @@ -291,12 +291,12 @@ void glvSnapshotClear(void); GLV_VK_SNAPSHOT glvSnapshotMerge(const GLV_VK_SNAPSHOT * const pDelta, const GLV_VK_SNAPSHOT * const pSnapshot); uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type); -VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray); +VkResult glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray); void glvSnapshotPrintObjects(void); // Func ptr typedefs typedef uint64_t (*GLVSNAPSHOT_GET_OBJECT_COUNT)(VK_OBJECT_TYPE); -typedef VK_RESULT (*GLVSNAPSHOT_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*); +typedef VkResult (*GLVSNAPSHOT_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*); typedef void (*GLVSNAPSHOT_PRINT_OBJECTS)(void); typedef void (*GLVSNAPSHOT_START_TRACKING)(void); typedef GLV_VK_SNAPSHOT (*GLVSNAPSHOT_GET_DELTA)(void); diff --git a/layers/layers_msg.h b/layers/layers_msg.h index b3525967..cda11051 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, - VK_VALIDATION_LEVEL validationLevel, - VK_BASE_OBJECT srcObject, + VkValidationLevel validationLevel, + VkBaseObject srcObject, size_t location, int32_t msgCode, const char* pLayerPrefix, diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index c05e07e2..bde5950a 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -50,18 +50,18 @@ static loader_platform_thread_mutex globalLock; #define MAX_BINDING 0xFFFFFFFF -map cbMap; -map memObjMap; -map objectMap; +map cbMap; +map memObjMap; +map objectMap; map fenceMap; // Map fenceId to fence info -map queueMap; +map queueMap; // TODO : Add per-device fence completion static uint64_t g_currentFenceId = 1; -static VK_DEVICE globalDevice = NULL; +static VkDevice globalDevice = NULL; // Add new queue for this device to map container -static void addQueueInfo(const VK_QUEUE queue) +static void addQueueInfo(const VkQueue queue) { MT_QUEUE_INFO* pInfo = new MT_QUEUE_INFO; pInfo->lastRetiredId = 0; @@ -72,23 +72,23 @@ static void addQueueInfo(const VK_QUEUE queue) static void deleteQueueInfoList(void) { // Process queue list, cleaning up each entry before deleting - for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { + for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { (*ii).second->pQueueCmdBuffers.clear(); } queueMap.clear(); } // Add new CBInfo for this cb to map container -static void addCBInfo(const VK_CMD_BUFFER cb) +static void addCBInfo(const VkCmdBuffer cb) { MT_CB_INFO* pInfo = new MT_CB_INFO; - memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list))); + memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list))); pInfo->cmdBuffer = cb; cbMap[cb] = pInfo; } // Return ptr to Info in CB map, or NULL if not found -static MT_CB_INFO* getCBInfo(const VK_CMD_BUFFER cb) +static MT_CB_INFO* getCBInfo(const VkCmdBuffer cb) { MT_CB_INFO* pCBInfo = NULL; if (cbMap.find(cb) != cbMap.end()) { @@ -98,7 +98,7 @@ static MT_CB_INFO* getCBInfo(const VK_CMD_BUFFER cb) } // Return object info for 'object' or return NULL if no info exists -static MT_OBJ_INFO* getObjectInfo(const VK_OBJECT object) +static MT_OBJ_INFO* getObjectInfo(const VkObject object) { MT_OBJ_INFO* pObjInfo = NULL; @@ -108,7 +108,7 @@ static MT_OBJ_INFO* getObjectInfo(const VK_OBJECT object) return pObjInfo; } -static MT_OBJ_INFO* addObjectInfo(VK_OBJECT object, VK_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix) +static MT_OBJ_INFO* addObjectInfo(VkObject object, VkStructureType sType, const void *pCreateInfo, const int struct_size, const char *name_prefix) { MT_OBJ_INFO* pInfo = new MT_OBJ_INFO; memset(pInfo, 0, sizeof(MT_OBJ_INFO)); @@ -124,7 +124,7 @@ static MT_OBJ_INFO* addObjectInfo(VK_OBJECT object, VK_STRUCTURE_TYPE sType, con } // Add a fence, creating one if necessary to our list of fences/fenceIds -static uint64_t addFenceInfo(VK_FENCE fence, VK_QUEUE queue) +static uint64_t addFenceInfo(VkFence fence, VkQueue queue) { // Create fence object MT_FENCE_INFO* pFenceInfo = new MT_FENCE_INFO; @@ -133,12 +133,12 @@ static uint64_t addFenceInfo(VK_FENCE fence, VK_QUEUE queue) memset(pFenceInfo, 0, sizeof(MT_FENCE_INFO)); // If no fence, create an internal fence to track the submissions if (fence == NULL) { - VK_FENCE_CREATE_INFO fci; + VkFenceCreateInfo fci; fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fci.pNext = NULL; - fci.flags = static_cast(0); + fci.flags = static_cast(0); nextTable.CreateFence(globalDevice, &fci, &pFenceInfo->fence); - addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(VK_FENCE_CREATE_INFO), "internalFence"); + addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(VkFenceCreateInfo), "internalFence"); pFenceInfo->localFence = VK_TRUE; } else { pFenceInfo->localFence = VK_FALSE; @@ -171,11 +171,11 @@ static void deleteFenceInfo(uint64_t fenceId) } // Search through list for this fence, deleting all items before it (with lower IDs) and updating lastRetiredId -static void updateFenceTracking(VK_FENCE fence) +static void updateFenceTracking(VkFence fence) { MT_FENCE_INFO *pCurFenceInfo = NULL; uint64_t fenceId = 0; - VK_QUEUE queue = NULL; + VkQueue queue = NULL; for (map::iterator ii=fenceMap.begin(); ii!=fenceMap.end(); ++ii) { if ((*ii).second != NULL) { @@ -214,9 +214,9 @@ static bool32_t fenceRetired(uint64_t fenceId) } // Return the fence associated with a fenceId -static VK_FENCE getFenceFromId(uint64_t fenceId) +static VkFence getFenceFromId(uint64_t fenceId) { - VK_FENCE fence = NULL; + VkFence fence = NULL; if (fenceId != 0) { // Search for an item with this fenceId if (fenceMap.find(fenceId) != fenceMap.end()) { @@ -233,7 +233,7 @@ static VK_FENCE getFenceFromId(uint64_t fenceId) } // Helper routine that updates the fence list for a specific queue to all-retired -static void retireQueueFences(VK_QUEUE queue) +static void retireQueueFences(VkQueue queue) { MT_QUEUE_INFO *pQueueInfo = queueMap[queue]; pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId; @@ -253,11 +253,11 @@ static void retireQueueFences(VK_QUEUE queue) } // Helper routine that updates fence list for all queues to all-retired -static void retireDeviceFences(VK_DEVICE device) +static void retireDeviceFences(VkDevice device) { // Process each queue for device // TODO: Add multiple device support - for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { + for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { retireQueueFences((*ii).first); } } @@ -265,11 +265,11 @@ static void retireDeviceFences(VK_DEVICE device) // Returns True if a memory reference is present in a Queue's memory reference list // Queue is validated by caller static bool32_t checkMemRef( - VK_QUEUE queue, - VK_GPU_MEMORY mem) + VkQueue queue, + VkGpuMemory mem) { bool32_t result = VK_FALSE; - list::iterator it; + list::iterator it; MT_QUEUE_INFO *pQueueInfo = queueMap[queue]; for (it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { if ((*it) == mem) { @@ -281,9 +281,9 @@ static bool32_t checkMemRef( } static bool32_t validateQueueMemRefs( - VK_QUEUE queue, + VkQueue queue, uint32_t cmdBufferCount, - const VK_CMD_BUFFER *pCmdBuffers) + const VkCmdBuffer *pCmdBuffers) { bool32_t result = VK_TRUE; @@ -305,7 +305,7 @@ static bool32_t validateQueueMemRefs( result = VK_FALSE; } else { // Validate that all actual references are accounted for in pMemRefs - for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { // Search for each memref in queues memreflist. if (checkMemRef(queue, *it)) { char str[1024]; @@ -335,7 +335,7 @@ static bool32_t validateQueueMemRefs( // Return ptr to info in map container containing mem, or NULL if not found // Calls to this function should be wrapped in mutex -static MT_MEM_OBJ_INFO* getMemObjInfo(const VK_GPU_MEMORY mem) +static MT_MEM_OBJ_INFO* getMemObjInfo(const VkGpuMemory mem) { MT_MEM_OBJ_INFO* pMemObjInfo = NULL; @@ -345,7 +345,7 @@ static MT_MEM_OBJ_INFO* getMemObjInfo(const VK_GPU_MEMORY mem) return pMemObjInfo; } -static void addMemObjInfo(const VK_GPU_MEMORY mem, const VkMemoryAllocInfo* pAllocInfo) +static void addMemObjInfo(const VkGpuMemory mem, const VkMemoryAllocInfo* pAllocInfo) { MT_MEM_OBJ_INFO* pInfo = new MT_MEM_OBJ_INFO; pInfo->refCount = 0; @@ -362,7 +362,7 @@ static void addMemObjInfo(const VK_GPU_MEMORY mem, const VkMemoryAllocInfo* pAll // Find CB Info and add mem binding to list container // Find Mem Obj Info and add CB binding to list container -static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) +static bool32_t updateCBBinding(const VkCmdBuffer cb, const VkGpuMemory mem) { bool32_t result = VK_TRUE; // First update CB binding in MemObj mini CB list @@ -375,7 +375,7 @@ static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) } else { // Search for cmd buffer object in memory object's binding list bool32_t found = VK_FALSE; - for (list::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) { + for (list::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) { if ((*it) == cb) { found = VK_TRUE; break; @@ -397,7 +397,7 @@ static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) } else { // Search for memory object in cmd buffer's binding list bool32_t found = VK_FALSE; - for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { if ((*it) == mem) { found = VK_TRUE; break; @@ -414,7 +414,7 @@ static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) // Clear the CB Binding for mem // Calls to this function should be wrapped in mutex -static void clearCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) +static void clearCBBinding(const VkCmdBuffer cb, const VkGpuMemory mem) { MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem); // TODO : Having this check is not ideal, really if memInfo was deleted, @@ -427,7 +427,7 @@ static void clearCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) } // Free bindings related to CB -static bool32_t freeCBBindings(const VK_CMD_BUFFER cb) +static bool32_t freeCBBindings(const VkCmdBuffer cb) { bool32_t result = VK_TRUE; MT_CB_INFO* pCBInfo = getCBInfo(cb); @@ -441,7 +441,7 @@ static bool32_t freeCBBindings(const VK_CMD_BUFFER cb) deleteFenceInfo(pCBInfo->fenceId); } - for (list::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) { clearCBBinding(cb, (*it)); } pCBInfo->pMemObjList.clear(); @@ -452,7 +452,7 @@ static bool32_t freeCBBindings(const VK_CMD_BUFFER cb) // Delete CBInfo from list along with all of it's mini MemObjInfo // and also clear mem references to CB // TODO : When should this be called? There's no Destroy of CBs that I see -static bool32_t deleteCBInfo(const VK_CMD_BUFFER cb) +static bool32_t deleteCBInfo(const VkCmdBuffer cb) { bool32_t result = VK_TRUE; result = freeCBBindings(cb); @@ -471,7 +471,7 @@ static bool32_t deleteCBInfo(const VK_CMD_BUFFER cb) static bool32_t deleteCBInfoList() { bool32_t result = VK_TRUE; - for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { + for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { freeCBBindings((*ii).first); delete (*ii).second; } @@ -483,13 +483,13 @@ static void reportMemReferences(const MT_MEM_OBJ_INFO* pMemObjInfo) { uint32_t refCount = 0; // Count found references - for (list::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) { + for (list::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) { refCount++; char str[1024]; sprintf(str, "Command Buffer %p has reference to mem obj %p", (*it), pMemObjInfo->mem); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str); } - for (list::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) { + for (list::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) { char str[1024]; sprintf(str, "VK Object %p has reference to mem obj %p", (*it), pMemObjInfo->mem); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str); @@ -501,7 +501,7 @@ static void reportMemReferences(const MT_MEM_OBJ_INFO* pMemObjInfo) } } -static void deleteMemObjInfo(VK_GPU_MEMORY mem) +static void deleteMemObjInfo(VkGpuMemory mem) { MT_MEM_OBJ_INFO* pDelInfo = memObjMap[mem]; if (memObjMap.find(mem) != memObjMap.end()) { @@ -512,7 +512,7 @@ static void deleteMemObjInfo(VK_GPU_MEMORY mem) } // Check if fence for given CB is completed -static bool32_t checkCBCompleted(const VK_CMD_BUFFER cb) +static bool32_t checkCBCompleted(const VkCmdBuffer cb) { bool32_t result = VK_TRUE; MT_CB_INFO* pCBInfo = getCBInfo(cb); @@ -532,7 +532,7 @@ static bool32_t checkCBCompleted(const VK_CMD_BUFFER cb) return result; } -static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal) +static bool32_t freeMemObjInfo(VkGpuMemory mem, bool internal) { bool32_t result = VK_TRUE; // Parse global list to find info w/ mem @@ -552,8 +552,8 @@ static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal) // Clear any CB bindings for completed CBs // TODO : Is there a better place to do this? - list::iterator it = pInfo->pCmdBufferBindings.begin(); - list::iterator temp; + list::iterator it = pInfo->pCmdBufferBindings.begin(); + list::iterator temp; while (it != pInfo->pCmdBufferBindings.end()) { if (VK_TRUE == checkCBCompleted(*it)) { temp = it; @@ -585,7 +585,7 @@ static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal) // 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it // 2. Decrement refCount for MemObjInfo // 3. Clear MemObjInfo ptr from ObjectInfo -static bool32_t clearObjectBinding(VK_OBJECT object) +static bool32_t clearObjectBinding(VkObject object) { bool32_t result = VK_FALSE; MT_OBJ_INFO* pObjInfo = getObjectInfo(object); @@ -599,7 +599,7 @@ static bool32_t clearObjectBinding(VK_OBJECT object) sprintf(str, "Attempting to clear mem binding on obj %p but it has no binding.", (void*)object); layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str); } else { - for (list::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) { + for (list::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) { pObjInfo->pMemObjInfo->refCount--; pObjInfo->pMemObjInfo = NULL; it = pObjInfo->pMemObjInfo->pObjBindings.erase(it); @@ -623,7 +623,7 @@ static bool32_t clearObjectBinding(VK_OBJECT object) // Add reference from objectInfo to memoryInfo // Add reference off of objInfo // Return VK_TRUE if addition is successful, VK_FALSE otherwise -static bool32_t updateObjectBinding(VK_OBJECT object, VK_GPU_MEMORY mem) +static bool32_t updateObjectBinding(VkObject object, VkGpuMemory mem) { bool32_t result = VK_FALSE; // Handle NULL case separately, just clear previous binding & decrement reference @@ -646,7 +646,7 @@ static bool32_t updateObjectBinding(VK_OBJECT object, VK_GPU_MEMORY mem) } else { // Search for object in memory object's binding list bool32_t found = VK_FALSE; - for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { + for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { if ((*it) == object) { found = VK_TRUE; break; @@ -683,7 +683,7 @@ static void printObjList() char str[1024]; sprintf(str, "Details of Object list of size %lu elements", objectMap.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (map::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) { + for (map::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) { pInfo = (*ii).second; sprintf(str, " ObjInfo %p has object %p, pMemObjInfo %p", pInfo, pInfo->object, pInfo->pMemObjInfo); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str); @@ -691,9 +691,9 @@ static void printObjList() } // For given Object, get 'mem' obj that it's bound to or NULL if no binding -static VK_GPU_MEMORY getMemBindingFromObject(const VK_OBJECT object) +static VkGpuMemory getMemBindingFromObject(const VkObject object) { - VK_GPU_MEMORY mem = NULL; + VkGpuMemory mem = NULL; MT_OBJ_INFO* pObjInfo = getObjectInfo(object); if (pObjInfo) { if (pObjInfo->pMemObjInfo) { @@ -724,7 +724,7 @@ static void printMemList() sprintf(str, "MEM INFO : Details of Memory Object list of size %lu elements", memObjMap.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { + for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { pInfo = (*ii).second; sprintf(str, " ===MemObjInfo at %p===", (void*)pInfo); @@ -744,14 +744,14 @@ static void printMemList() sprintf(str, " VK OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { + for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { sprintf(str, " VK OBJECT %p", (*it)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); } sprintf(str, " VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (list::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) { + for (list::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) { sprintf(str, " VK CB %p", (*it)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); } @@ -765,7 +765,7 @@ static void printCBList() sprintf(str, "Details of CB list of size %lu elements", cbMap.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { + for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { pCBInfo = (*ii).second; sprintf(str, " CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %p", @@ -773,7 +773,7 @@ static void printCBList() (void*)getFenceFromId(pCBInfo->fenceId)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { sprintf(str, " Mem obj %p", (*it)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); } @@ -800,13 +800,13 @@ static void initMemTracker(void) // initialize Layer dispatch table // TODO handle multiple GPUs - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); - vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr"); + PFN_vkGetProcAddr fpGetProcAddr = (PFN_vkGetProcAddr)fpNextGPA((VkPhysicalGpu) pCurObj->nextObject, (char *) "vkGetProcAddr"); nextTable.GetProcAddr = fpGetProcAddr; if (!globalLockInitialized) @@ -821,18 +821,18 @@ static void initMemTracker(void) } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initMemTracker); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // Save off device in case we need it to create Fences globalDevice = *pDevice; return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { char str[1024]; sprintf(str, "Printing List details prior to vkDestroyDevice()"); @@ -847,7 +847,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) } // Report any memory leaks MT_MEM_OBJ_INFO* pInfo = NULL; - for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { + for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { pInfo = (*ii).second; if (pInfo->allocInfo.allocationSize != 0) { @@ -861,21 +861,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) deleteQueueInfoList(); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; - VK_RESULT result; + VkResult result; /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */ if (!strcmp(pExtName, "MemTracker")) { result = VK_SUCCESS; } else if (nextTable.GetExtensionSupport != NULL) { - result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else { result = VK_ERROR_INVALID_EXTENSION; @@ -883,7 +883,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) @@ -891,7 +891,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initMemTracker); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else @@ -905,9 +905,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue) +VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) { - VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); addQueueInfo(*pQueue); @@ -916,9 +916,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queu return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory mem) { - VK_RESULT result = nextTable.QueueAddMemReference(queue, mem); + VkResult result = nextTable.QueueAddMemReference(queue, mem); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); @@ -945,10 +945,10 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_ME return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReference(VkQueue queue, VkGpuMemory mem) { // TODO : Decrement ref count for this memory reference on this queue. Remove if ref count is zero. - VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem); + VkResult result = nextTable.QueueRemoveMemReference(queue, mem); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); @@ -959,7 +959,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str); } else { - for (list::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { + for (list::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { if ((*it) == mem) { it = pQueueInfo->pMemRefList.erase(it); } @@ -970,11 +970,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit( - VK_QUEUE queue, +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit( + VkQueue queue, uint32_t cmdBufferCount, - const VK_CMD_BUFFER *pCmdBuffers, - VK_FENCE fence) + const VkCmdBuffer *pCmdBuffers, + VkFence fence) { loader_platform_thread_lock_mutex(&globalLock); // TODO : Need to track fence and clear mem references when fence clears @@ -995,13 +995,13 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit( } loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId)); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId)); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem); + VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem); // TODO : Track allocations and overall size here loader_platform_thread_lock_mutex(&globalLock); addMemObjInfo(*pMem, pAllocInfo); @@ -1010,7 +1010,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAl return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkGpuMemory 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 @@ -1026,19 +1026,19 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) printObjList(); printCBList(); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkGpuMemory mem, VkMemoryPriority priority) { // TODO : Update tracking for this alloc // Make sure memory is not pinned, which can't have priority set - VK_RESULT result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(mem, priority); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkGpuMemory mem, VkFlags flags, void** ppData) { // TODO : Track when memory is mapped loader_platform_thread_lock_mutex(&globalLock); @@ -1049,54 +1049,54 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, v layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str); } loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.MapMemory(mem, flags, ppData); + VkResult result = nextTable.MapMemory(mem, flags, ppData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkGpuMemory 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 - VK_RESULT result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem) { // TODO : Track this // Verify that memory is actually pinnable - VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); + VkResult result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { // TODO : Track this - VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { // TODO : Track this - VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* pMem) { // TODO : Track this - VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); + VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { loader_platform_thread_lock_mutex(&globalLock); // First check if this is a CmdBuffer - if (NULL != getCBInfo((VK_CMD_BUFFER)object)) { - deleteCBInfo((VK_CMD_BUFFER)object); + if (NULL != getCBInfo((VkCmdBuffer)object)) { + deleteCBInfo((VkCmdBuffer)object); } if (objectMap.find(object) != objectMap.end()) { @@ -1104,7 +1104,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) if (pDelInfo->pMemObjInfo) { // Wsi allocated Memory is tied to image object so clear the binding and free that memory automatically if (0 == pDelInfo->pMemObjInfo->allocInfo.allocationSize) { // Wsi allocated memory has NULL allocInfo w/ 0 size - VK_GPU_MEMORY memToFree = pDelInfo->pMemObjInfo->mem; + VkGpuMemory memToFree = pDelInfo->pMemObjInfo->mem; clearObjectBinding(object); freeMemObjInfo(memToFree, true); } @@ -1121,22 +1121,22 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) } loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(object); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { // TODO : What to track here? // Could potentially save returned mem requirements and validate values passed into BindObjectMemory 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. - VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset) { - VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); + VkResult result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); loader_platform_thread_lock_mutex(&globalLock); // Track objects tied to memory if (VK_FALSE == updateObjectBinding(object, mem)) { @@ -1150,20 +1150,20 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t al return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) { - VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence); + VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VK_FENCE_CREATE_INFO), "fence"); + addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VkFenceCreateInfo), "fence"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences) +VK_LAYER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences) { - VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences); + VkResult result = nextTable.ResetFences(device, fenceCount, pFences); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); // Reset fence state in fenceCreateInfo structure @@ -1171,7 +1171,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCo MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]); if (pObjectInfo != NULL) { pObjectInfo->create_info.fence_create_info.flags = - static_cast(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT); + static_cast(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT); } } loader_platform_thread_unlock_mutex(&globalLock); @@ -1179,9 +1179,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCo return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) { - VK_RESULT result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(fence); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); updateFenceTracking(fence); @@ -1190,7 +1190,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout) +VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) { // Verify fence status of submitted fences for(uint32_t i = 0; i < fenceCount; i++) { @@ -1204,7 +1204,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fence } } - VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); + VkResult result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); loader_platform_thread_lock_mutex(&globalLock); if (VK_SUCCESS == result) { @@ -1218,9 +1218,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fence return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) { - VK_RESULT result = nextTable.QueueWaitIdle(queue); + VkResult result = nextTable.QueueWaitIdle(queue); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); retireQueueFences(queue); @@ -1229,9 +1229,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) { - VK_RESULT result = nextTable.DeviceWaitIdle(device); + VkResult result = nextTable.DeviceWaitIdle(device); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); retireDeviceFences(device); @@ -1240,31 +1240,31 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent) +VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) { - VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent); + VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VK_EVENT_CREATE_INFO), "event"); + addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VkEventCreateInfo), "event"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) { - VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); + VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VK_QUERY_POOL_CREATE_INFO), "query_pool"); + addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VkQueryPoolCreateInfo), "query_pool"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { - VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); + VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferCreateInfo), "buffer"); @@ -1273,9 +1273,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferViewCreateInfo), "buffer_view"); @@ -1284,156 +1284,156 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { - VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage); + VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_CREATE_INFO), "image"); + addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VkImageCreateInfo), "image"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_VIEW_CREATE_INFO), "image_view"); + addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkImageViewCreateInfo), "image_view"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - VK_COLOR_ATTACHMENT_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, + VkColorAttachmentView* pView) { - VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO), "color_attachment_view"); + addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkColorAttachmentViewCreateInfo), "color_attachment_view"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) { - VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_DEPTH_STENCIL_VIEW_CREATE_INFO), "ds_view"); + addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkDepthStencilViewCreateInfo), "ds_view"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader) +VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { - VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader); + VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline"); + addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline basePipeline, + VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); + VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline"); + addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_COMPUTE_PIPELINE_CREATE_INFO), "compute_pipeline"); + addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkComputePipelineCreateInfo), "compute_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VK_SAMPLER_CREATE_INFO), "sampler"); + addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VkSamplerCreateInfo), "sampler"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, + VkDynamicVpStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO), "viewport_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo), "viewport_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, + VkDynamicRsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO), "raster_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo), "raster_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, + VkDynamicCbStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO), "cb_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo), "cb_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, + VkDynamicDsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO), "ds_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo), "ds_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer loader_platform_thread_lock_mutex(&globalLock); if (*pCmdBuffer) @@ -1443,7 +1443,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer); @@ -1455,21 +1455,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str); } } - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); loader_platform_thread_lock_mutex(&globalLock); freeCBBindings(cmdBuffer); loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { // TODO : Anything to do here? - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { // Verify that CB is complete (not in-flight) MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer); @@ -1485,12 +1485,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) loader_platform_thread_lock_mutex(&globalLock); freeCBBindings(cmdBuffer); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); return result; } // TODO : For any vkCmdBind* calls that include an object which has mem bound to it, // need to account for that mem now having binding to given cmdBuffer -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { #if 0 // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer @@ -1513,7 +1513,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { MT_OBJ_INFO *pObjInfo; loader_platform_thread_lock_mutex(&globalLock); @@ -1535,32 +1535,32 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, } VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets, + const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(buffer); + VkGpuMemory mem = getMemBindingFromObject(buffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer); @@ -1570,10 +1570,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(buffer); + VkGpuMemory mem = getMemBindingFromObject(buffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer); @@ -1583,10 +1583,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_ nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(buffer); + VkGpuMemory mem = getMemBindingFromObject(buffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer); @@ -1596,11 +1596,11 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, - uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, + uint32_t regionCount, const VkBufferCopy* pRegions) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcBuffer); + VkGpuMemory mem = getMemBindingFromObject(srcBuffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer); @@ -1616,32 +1616,32 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageCopy* pRegions) { // TODO : Each image will have mem mapping so track them nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_BLIT* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageBlit* pRegions) { // TODO : Each image will have mem mapping so track them nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { // TODO : Track this loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(destImage); + VkGpuMemory mem = getMemBindingFromObject(destImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer); @@ -1658,14 +1658,14 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkBuffer destBuffer, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { // TODO : Track this loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage); + VkGpuMemory mem = getMemBindingFromObject(srcImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer); @@ -1681,12 +1681,12 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout) { // TODO : Each image will have mem mapping so track them loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage); + VkGpuMemory mem = getMemBindingFromObject(srcImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCloneImageData() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer); @@ -1702,10 +1702,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer); + VkGpuMemory mem = getMemBindingFromObject(destBuffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer); @@ -1715,10 +1715,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer); + VkGpuMemory mem = getMemBindingFromObject(destBuffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer); @@ -1728,14 +1728,14 @@ VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER de nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, + VkClearColor color, + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(image); + VkGpuMemory mem = getMemBindingFromObject(image); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer); @@ -1745,14 +1745,14 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(image); + VkGpuMemory mem = getMemBindingFromObject(image); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer); @@ -1762,13 +1762,13 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t rectCount, const VkImageResolve* pRects) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage); + VkGpuMemory mem = getMemBindingFromObject(srcImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer); @@ -1784,10 +1784,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool); + VkGpuMemory mem = getMemBindingFromObject(queryPool); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer); @@ -1797,10 +1797,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POO nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool); + VkGpuMemory mem = getMemBindingFromObject(queryPool); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer); @@ -1810,10 +1810,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool); + VkGpuMemory mem = getMemBindingFromObject(queryPool); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer); @@ -1823,7 +1823,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE)); @@ -1837,11 +1837,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo; @@ -1864,19 +1864,19 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK)); } } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } #if !defined(WIN32) -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, + VkImage* pImage, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); + VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); loader_platform_thread_lock_mutex(&globalLock); if (VK_SUCCESS == result) { // Add image object, then insert the new Mem Object and then bind it to created image - addObjectInfo(*pImage, _VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image"); + addObjectInfo(*pImage, VkStructureType__MAX_ENUM, pCreateInfo, sizeof(VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image"); addMemObjInfo(*pMem, NULL); if (VK_FALSE == updateObjectBinding(*pImage, *pMem)) { char str[1024]; @@ -1890,7 +1890,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence) { loader_platform_thread_lock_mutex(&globalLock); addFenceInfo(fence, queue); @@ -1898,12 +1898,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WS sprintf(str, "In vkWsiX11QueuePresent(), checking queue %p for fence %p", queue, fence); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); + VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); return result; } #endif // WIN32 -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -2063,6 +2063,6 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h index d3a8608f..b0b9d6b8 100644 --- a/layers/mem_tracker.h +++ b/layers/mem_tracker.h @@ -85,29 +85,29 @@ typedef enum _MEM_TRACK_ERROR // Data struct for tracking memory object struct MT_MEM_OBJ_INFO { uint32_t refCount; // Count of references (obj bindings or CB use) - VK_GPU_MEMORY mem; + VkGpuMemory mem; VkMemoryAllocInfo allocInfo; - list pObjBindings; // list container of objects bound to this memory - list pCmdBufferBindings; // list container of cmd buffers that reference this mem object + list pObjBindings; // list container of objects bound to this memory + list pCmdBufferBindings; // list container of cmd buffers that reference this mem object }; struct MT_OBJ_INFO { MT_MEM_OBJ_INFO* pMemObjInfo; - VK_OBJECT object; - VK_STRUCTURE_TYPE sType; + VkObject object; + VkStructureType sType; uint32_t ref_count; // Capture all object types that may have memory bound. From prog guide: // The only objects that are guaranteed to have no external memory // requirements are devices, queues, command buffers, shaders and memory objects. union { - VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO color_attachment_view_create_info; - VK_DEPTH_STENCIL_VIEW_CREATE_INFO ds_view_create_info; - VK_IMAGE_VIEW_CREATE_INFO image_view_create_info; - VK_IMAGE_CREATE_INFO image_create_info; - VK_GRAPHICS_PIPELINE_CREATE_INFO graphics_pipeline_create_info; - VK_COMPUTE_PIPELINE_CREATE_INFO compute_pipeline_create_info; - VK_SAMPLER_CREATE_INFO sampler_create_info; - VK_FENCE_CREATE_INFO fence_create_info; + VkColorAttachmentViewCreateInfo color_attachment_view_create_info; + VkDepthStencilViewCreateInfo ds_view_create_info; + VkImageViewCreateInfo image_view_create_info; + VkImageCreateInfo image_create_info; + VkGraphicsPipelineCreateInfo graphics_pipeline_create_info; + VkComputePipelineCreateInfo compute_pipeline_create_info; + VkSamplerCreateInfo sampler_create_info; + VkFenceCreateInfo fence_create_info; #ifndef _WIN32 VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO wsi_x11_presentable_image_create_info; #endif // _WIN32 @@ -117,21 +117,21 @@ struct MT_OBJ_INFO { // Track all command buffers struct MT_CB_INFO { - VK_CMD_BUFFER_CREATE_INFO createInfo; + VkCmdBufferCreateInfo createInfo; MT_OBJ_INFO* pDynamicState[VK_NUM_STATE_BIND_POINT]; - VK_PIPELINE pipelines[VK_NUM_PIPELINE_BIND_POINT]; + VkPipeline pipelines[VK_NUM_PIPELINE_BIND_POINT]; uint32_t colorAttachmentCount; - VK_DEPTH_STENCIL_BIND_INFO dsBindInfo; - VK_CMD_BUFFER cmdBuffer; + VkDepthStencilBindInfo dsBindInfo; + VkCmdBuffer cmdBuffer; uint64_t fenceId; // Order dependent, stl containers must be at end of struct - list pMemObjList; // List container of Mem objs referenced by this CB + list pMemObjList; // List container of Mem objs referenced by this CB }; // Associate fenceId with a fence object struct MT_FENCE_INFO { - VK_FENCE fence; // Handle to fence object - VK_QUEUE queue; // Queue that this fence is submitted against + VkFence fence; // Handle to fence object + VkQueue queue; // Queue that this fence is submitted against bool32_t localFence; // Is fence created by layer? }; @@ -139,8 +139,8 @@ struct MT_FENCE_INFO { struct MT_QUEUE_INFO { uint64_t lastRetiredId; uint64_t lastSubmittedId; - list pQueueCmdBuffers; - list pMemRefList; + list pQueueCmdBuffers; + list pMemRefList; }; #ifdef __cplusplus diff --git a/layers/multi.cpp b/layers/multi.cpp index 3f967d6a..1c9dc178 100644 --- a/layers/multi.cpp +++ b/layers/multi.cpp @@ -62,44 +62,44 @@ extern "C" { #endif -VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, - VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI multi1CreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, + VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw); printf("At start of multi1 layer vkCreateDevice()\n"); - VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // create a mapping for the device object into the dispatch table tableMap1.emplace(*pDevice, pTable); printf("Completed multi1 layer vkCreateDevice()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline* pPipeline) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[device]; printf("At start of multi1 layer vkCreateGraphicsPipeline()\n"); - VK_RESULT result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); // create a mapping for the pipeline object into the dispatch table tableMap1.emplace(*pPipeline, pTable); printf("Completed multi1 layer vkCreateGraphicsPipeline()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi1StorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI multi1StorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[pipeline]; printf("At start of multi1 layer vkStorePipeline()\n"); - VK_RESULT result = pTable->StorePipeline(pipeline, pDataSize, pData); + VkResult result = pTable->StorePipeline(pipeline, pDataSize, pData); printf("Completed multi1 layer vkStorePipeline()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi1EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, +VK_LAYER_EXPORT VkResult VKAPI multi1EnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { @@ -110,12 +110,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI multi1EnumerateLayers(VK_PHYSICAL_GPU gpu, size_ VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw); printf("At start of multi1 layer vkEnumerateLayers()\n"); - VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); printf("Completed multi1 layer vkEnumerateLayers()\n"); return result; } -VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VkPhysicalGpu gpu, const char* pName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -137,7 +137,7 @@ VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VK_PHYSICAL_GPU gpu, const char* else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName); + return gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, pName); } } @@ -163,45 +163,45 @@ static VK_LAYER_DISPATCH_TABLE * getLayer2Table(const VK_BASE_LAYER_OBJECT *gpuw } } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, - VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI multi2CreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, + VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw); printf("At start of multi2 vkCreateDevice()\n"); - VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // create a mapping for the device object into the dispatch table for layer2 tableMap2.emplace(*pDevice, pTable); printf("Completed multi2 layer vkCreateDevice()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, - VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI multi2CreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, + VkCmdBuffer* pCmdBuffer) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[device]; printf("At start of multi2 layer vkCreateCommandBuffer()\n"); - VK_RESULT result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); // create a mapping for CmdBuffer object into the dispatch table for layer 2 tableMap2.emplace(*pCmdBuffer, pTable); printf("Completed multi2 layer vkCreateCommandBuffer()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2BeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI multi2BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer]; printf("At start of multi2 layer vkBeginCommandBuffer()\n"); - VK_RESULT result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo); printf("Completed multi2 layer vkBeginCommandBuffer()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, +VK_LAYER_EXPORT VkResult VKAPI multi2EnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { @@ -212,12 +212,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI multi2EnumerateLayers(VK_PHYSICAL_GPU gpu, size_ VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw); printf("At start of multi2 layer vkEnumerateLayers()\n"); - VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); printf("Completed multi2 layer vkEnumerateLayers()\n"); return result; } -VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VkPhysicalGpu gpu, const char* pName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -239,12 +239,12 @@ VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VK_PHYSICAL_GPU gpu, const char* else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName); + return gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, pName); } } /********************************* Common functions ********************************/ -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { @@ -259,9 +259,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma return VK_SUCCESS; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { - VK_RESULT result; + VkResult result; VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */ @@ -274,11 +274,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const } else if (!tableMap1.empty() && (tableMap1.find(gpuw) != tableMap1.end())) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[gpuw]; - result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else if (!tableMap2.empty() && (tableMap2.find(gpuw) != tableMap2.end())) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[gpuw]; - result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else { result = VK_ERROR_INVALID_EXTENSION; @@ -286,7 +286,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* pName) { // to find each layers GPA routine Loader will search via "GetProcAddr" if (!strncmp("multi1GetProcAddr", pName, sizeof("multi1GetProcAddr"))) @@ -317,5 +317,5 @@ static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_T if (layerNum == 1 && layer2_first_activated == false) layer1_first_activated = true; - layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject); + layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VkPhysicalGpu) gpuw->nextObject); } diff --git a/layers/object_track.h b/layers/object_track.h index a0050c86..cc45d7e3 100644 --- a/layers/object_track.h +++ b/layers/object_track.h @@ -174,8 +174,8 @@ typedef struct _OBJTRACK_NODE { // prototype for extension functions uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type); -VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray); +VkResult objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray); // Func ptr typedefs typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(VK_OBJECT_TYPE); -typedef VK_RESULT (*OBJ_TRACK_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*); +typedef VkResult (*OBJ_TRACK_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*); diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index 9be48ade..bd9646e1 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -64,18 +64,18 @@ static void initParamChecker(void) g_logFile = stdout; } - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); } -void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLBACKS* pAllocCb) +void PreCreateInstance(const VkApplicationInfo* pAppInfo, const VkAllocCallbacks* pAllocCb) { if(pAppInfo == nullptr) { - char const str[] = "vkCreateInstance parameter, VK_APPLICATION_INFO* pAppInfo, is "\ + char const str[] = "vkCreateInstance parameter, VkApplicationInfo* pAppInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -97,7 +97,7 @@ void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLB { if(!vk_validate_vk_alloc_callbacks(pAllocCb)) { - char const str[] = "vkCreateInstance parameter, VK_ALLOC_CALLBACKS* pAllocCb, "\ + char const str[] = "vkCreateInstance parameter, VkAllocCallbacks* pAllocCb, "\ "contains an invalid value (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -105,11 +105,11 @@ void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLB } } -void PostCreateInstance(VK_RESULT result, VK_INSTANCE* pInstance) +void PostCreateInstance(VkResult result, VkInstance* pInstance) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateInstance failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -117,36 +117,36 @@ void PostCreateInstance(VK_RESULT result, VK_INSTANCE* pInstance) if(pInstance == nullptr) { - char const str[] = "vkCreateInstance parameter, VK_INSTANCE* pInstance, is nullptr "\ + char const str[] = "vkCreateInstance parameter, VkInstance* pInstance, is nullptr "\ "(postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance) +VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) { PreCreateInstance(pCreateInfo->pAppInfo, pCreateInfo->pAllocCb); - VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance); + VkResult result = nextTable.CreateInstance(pCreateInfo, pInstance); PostCreateInstance(result, pInstance); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance) { - VK_RESULT result = nextTable.DestroyInstance(instance); + VkResult result = nextTable.DestroyInstance(instance); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateGpus(VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, VkPhysicalGpu* pGpus) { - VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); + VkResult result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; @@ -156,15 +156,15 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GP sprintf(str, "Parameter infoType to function GetGpuInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData); + VkResult result = nextTable.GetGpuInfo((VkPhysicalGpu)gpuw->nextObject, infoType, pDataSize, pData); return result; } -void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo) +void PreCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo) { if(gpu == nullptr) { - char const str[] = "vkCreateDevice parameter, VK_PHYSICAL_GPU gpu, is nullptr "\ + char const str[] = "vkCreateDevice parameter, VkPhysicalGpu gpu, is nullptr "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -216,18 +216,18 @@ void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo) if(!validate_VK_VALIDATION_LEVEL(pCreateInfo->maxValidationLevel)) { - char const str[] = "vkCreateDevice parameter, VK_VALIDATION_LEVEL pCreateInfo->maxValidationLevel, is "\ + char const str[] = "vkCreateDevice parameter, VkValidationLevel pCreateInfo->maxValidationLevel, is "\ "unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -void PostCreateDevice(VK_RESULT result, VK_DEVICE* pDevice) +void PostCreateDevice(VkResult result, VkDevice* pDevice) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateDevice failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -235,41 +235,41 @@ void PostCreateDevice(VK_RESULT result, VK_DEVICE* pDevice) if(pDevice == nullptr) { - char const str[] = "vkCreateDevice parameter, VK_DEVICE* pDevice, is nullptr (postcondition)."; + char const str[] = "vkCreateDevice parameter, VkDevice* pDevice, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); PreCreateDevice(gpu, pCreateInfo); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); PostCreateDevice(result, pDevice); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + VkResult result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { char str[1024]; if (gpu != NULL) { @@ -278,7 +278,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); sprintf(str, "Completed layered EnumerateLayers\n"); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str); fflush(stdout); @@ -293,45 +293,45 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue) +VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) { - VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) { - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory mem) { - VK_RESULT result = nextTable.QueueAddMemReference(queue, mem); + VkResult result = nextTable.QueueAddMemReference(queue, mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReference(VkQueue queue, VkGpuMemory mem) { - VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem); + VkResult result = nextTable.QueueRemoveMemReference(queue, mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) { - VK_RESULT result = nextTable.QueueWaitIdle(queue); + VkResult result = nextTable.QueueWaitIdle(queue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) { - VK_RESULT result = nextTable.DeviceWaitIdle(device); + VkResult result = nextTable.DeviceWaitIdle(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem) { char str[1024]; if (!pAllocInfo) { @@ -341,60 +341,60 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAl sprintf(str, "Parameter pAllocInfo to function AllocMemory contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem); + VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkGpuMemory mem) { - VK_RESULT result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkGpuMemory mem, VkMemoryPriority priority) { char str[1024]; if (!validate_VK_MEMORY_PRIORITY(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); } - VK_RESULT result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(mem, priority); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkGpuMemory mem, VkFlags flags, void** ppData) { - VK_RESULT result = nextTable.MapMemory(mem, flags, ppData); + VkResult result = nextTable.MapMemory(mem, flags, ppData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkGpuMemory mem) { - VK_RESULT result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); + VkResult result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo) +VK_LAYER_EXPORT VkResult VKAPI vkGetMultiGpuCompatibility(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo); + VkResult result = nextTable.GetMultiGpuCompatibility((VkPhysicalGpu)gpuw->nextObject, gpu1, pInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { char str[1024]; if (!pOpenInfo) { @@ -405,11 +405,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_ME sprintf(str, "Parameter pOpenInfo to function OpenSharedMemory contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedSemaphore(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) { char str[1024]; if (!pOpenInfo) { @@ -420,11 +420,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK sprintf(str, "Parameter pOpenInfo to function OpenSharedSemaphore contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); + VkResult result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { char str[1024]; if (!pOpenInfo) { @@ -435,11 +435,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER sprintf(str, "Parameter pOpenInfo to function OpenPeerMemory contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* pMem) { char str[1024]; if (!pOpenInfo) { @@ -450,43 +450,43 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_ sprintf(str, "Parameter pOpenInfo to function OpenPeerImage contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); + VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(object); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!validate_VK_OBJECT_INFO_TYPE(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); } - VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset) { - VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); + VkResult result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset, VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset) { - VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); + VkResult result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindImageMemoryRange(VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* bindInfo, VkGpuMemory mem, VkGpuSize memOffset) { char str[1024]; if (!bindInfo) { @@ -497,11 +497,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t sprintf(str, "Parameter bindInfo to function BindImageMemoryRange contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); + VkResult result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) { char str[1024]; if (!pCreateInfo) { @@ -512,32 +512,32 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_C sprintf(str, "Parameter pCreateInfo to function CreateFence contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence); + VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) { - VK_RESULT result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout) +VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) { - VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); + VkResult result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences) +VK_LAYER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences) { - VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences); + VkResult result = nextTable.ResetFences(device, fenceCount, pFences); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { char str[1024]; if (!pCreateInfo) { @@ -548,25 +548,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEM sprintf(str, "Parameter pCreateInfo to function CreateSemaphore contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); + VkResult result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore); + VkResult result = nextTable.QueueSignalSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore); + VkResult result = nextTable.QueueWaitSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent) +VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) { char str[1024]; if (!pCreateInfo) { @@ -577,32 +577,32 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_C sprintf(str, "Parameter pCreateInfo to function CreateEvent contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent); + VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkEvent event) { - VK_RESULT result = nextTable.GetEventStatus(event); + VkResult result = nextTable.GetEventStatus(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkEvent event) { - VK_RESULT result = nextTable.SetEvent(event); + VkResult result = nextTable.SetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkEvent event) { - VK_RESULT result = nextTable.ResetEvent(event); + VkResult result = nextTable.ResetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) { char str[1024]; if (!pCreateInfo) { @@ -613,18 +613,18 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUE sprintf(str, "Parameter pCreateInfo to function CreateQueryPool contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); + VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) { - VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); + VkResult result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!validate_VK_FORMAT(format)) { @@ -635,11 +635,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT form sprintf(str, "Parameter infoType to function GetFormatInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); + VkResult result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { char str[1024]; if (!pCreateInfo) { @@ -650,11 +650,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferC sprintf(str, "Parameter pCreateInfo to function CreateBuffer contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); + VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { char str[1024]; if (!pCreateInfo) { @@ -665,15 +665,15 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf sprintf(str, "Parameter pCreateInfo to function CreateBufferView contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); return result; } -void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) +void PreCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo) { if(pCreateInfo == nullptr) { - char const str[] = "vkCreateImage parameter, VK_IMAGE_CREATE_INFO* pCreateInfo, is "\ + char const str[] = "vkCreateImage parameter, VkImageCreateInfo* pCreateInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -689,7 +689,7 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if (!validate_VK_IMAGE_TYPE(pCreateInfo->imageType)) { - char const str[] = "vkCreateImage parameter, VK_IMAGE_TYPE pCreateInfo->imageType, is "\ + char const str[] = "vkCreateImage parameter, VkImageType pCreateInfo->imageType, is "\ "unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -697,19 +697,19 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if (!validate_VK_FORMAT(pCreateInfo->format)) { - char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, is "\ + char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, is "\ "unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } - VK_FORMAT_PROPERTIES properties; + VkFormatProperties properties; size_t size = sizeof(properties); - VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->format, + VkResult result = nextTable.GetFormatInfo(device, pCreateInfo->format, VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties); if(result != VK_SUCCESS) { - char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, cannot be "\ + char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, cannot be "\ "validated (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -717,7 +717,7 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) { - char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, contains "\ + char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, contains "\ "unsupported format (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -726,7 +726,7 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) // TODO: Can we check device-specific limits? if (!vk_validate_vk_extent3d(&pCreateInfo->extent)) { - char const str[] = "vkCreateImage parameter, VK_EXTENT3D pCreateInfo->extent, is invalid "\ + char const str[] = "vkCreateImage parameter, VkExtent3D pCreateInfo->extent, is invalid "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -734,18 +734,18 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if (!validate_VK_IMAGE_TILING(pCreateInfo->tiling)) { - char const str[] = "vkCreateImage parameter, VK_IMAGE_TILING pCreateInfo->tiling, is "\ + char const str[] = "vkCreateImage parameter, VkImageTiling pCreateInfo->tiling, is "\ "unrecoginized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -void PostCreateImage(VK_RESULT result, VK_IMAGE* pImage) +void PostCreateImage(VkResult result, VkImage* pImage) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateImage failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -753,21 +753,21 @@ void PostCreateImage(VK_RESULT result, VK_IMAGE* pImage) if(pImage == nullptr) { - char const str[] = "vkCreateImage parameter, VK_IMAGE* pImage, is nullptr (postcondition)."; + char const str[] = "vkCreateImage parameter, VkImage* pImage, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { PreCreateImage(device, pCreateInfo); - VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage); + VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage); PostCreateImage(result, pImage); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!pSubresource) { @@ -782,11 +782,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const 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); } - VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); + VkResult result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { char str[1024]; if (!pCreateInfo) { @@ -797,11 +797,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMA sprintf(str, "Parameter pCreateInfo to function CreateImageView contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) { char str[1024]; if (!pCreateInfo) { @@ -812,11 +812,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, co sprintf(str, "Parameter pCreateInfo to function CreateColorAttachmentView contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) { char str[1024]; if (!pCreateInfo) { @@ -827,11 +827,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const sprintf(str, "Parameter pCreateInfo to function CreateDepthStencilView contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader) +VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { char str[1024]; if (!pCreateInfo) { @@ -842,11 +842,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER sprintf(str, "Parameter pCreateInfo to function CreateShader contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader); + VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { char str[1024]; if (!pCreateInfo) { @@ -857,11 +857,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipeline contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) { char str[1024]; if (!pCreateInfo) { @@ -872,11 +872,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(VK_DEVICE dev sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipelineDerivative contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); + VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { char str[1024]; if (!pCreateInfo) { @@ -887,32 +887,32 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const sprintf(str, "Parameter pCreateInfo to function CreateComputePipeline contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) { - VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData); + VkResult result = nextTable.StorePipeline(pipeline, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); + VkResult result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipelineDerivative(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); + VkResult result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { char str[1024]; if (!pCreateInfo) { @@ -923,11 +923,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPL sprintf(str, "Parameter pCreateInfo to function CreateSampler contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { char str[1024]; if (!pCreateInfo) { @@ -938,36 +938,36 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, co sprintf(str, "Parameter pCreateInfo to function CreateDescriptorSetLayout contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayoutChain(VkDevice device, uint32_t setLayoutArrayCount, const VkDescriptorSetLayout* pSetLayoutArray, VkDescriptorSetLayoutChain* pLayoutChain) { - VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); + VkResult result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode) +VK_LAYER_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate(VkDevice device, VkDescriptorUpdateMode updateMode) { char str[1024]; if (!validate_VK_DESCRIPTOR_UPDATE_MODE(updateMode)) { sprintf(str, "Parameter updateMode to function BeginDescriptorPoolUpdate has invalid value of %i.", (int)updateMode); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); + VkResult result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd) +VK_LAYER_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate(VkDevice device, VkCmdBuffer cmd) { - VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd); + VkResult result = nextTable.EndDescriptorPoolUpdate(device, cmd); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { char str[1024]; if (!validate_VK_DESCRIPTOR_POOL_USAGE(poolUsage)) { @@ -982,41 +982,41 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESC sprintf(str, "Parameter pCreateInfo to function CreateDescriptorPool contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) { - VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(descriptorPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { char str[1024]; if (!validate_VK_DESCRIPTOR_SET_USAGE(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); } - VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1027,11 +1027,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, c sprintf(str, "Parameter pCreateInfo to function CreateDynamicViewportState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1042,11 +1042,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, con sprintf(str, "Parameter pCreateInfo to function CreateDynamicRasterState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1057,11 +1057,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, sprintf(str, "Parameter pCreateInfo to function CreateDynamicColorBlendState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1072,15 +1072,15 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE devic sprintf(str, "Parameter pCreateInfo to function CreateDynamicDepthStencilState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); return result; } -void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo) +void PreCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo) { if(device == nullptr) { - char const str[] = "vkCreateCommandBuffer parameter, VK_DEVICE device, is "\ + char const str[] = "vkCreateCommandBuffer parameter, VkDevice device, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1088,7 +1088,7 @@ void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* p if(pCreateInfo == nullptr) { - char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, is "\ + char const str[] = "vkCreateCommandBuffer parameter, VkCmdBufferCreateInfo* pCreateInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1103,11 +1103,11 @@ void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* p } } -void PostCreateCommandBuffer(VK_RESULT result, VK_CMD_BUFFER* pCmdBuffer) +void PostCreateCommandBuffer(VkResult result, VkCmdBuffer* pCmdBuffer) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateCommandBuffer failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1115,22 +1115,22 @@ void PostCreateCommandBuffer(VK_RESULT result, VK_CMD_BUFFER* pCmdBuffer) if(pCmdBuffer == nullptr) { - char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER* pCmdBuffer, is nullptr (postcondition)."; + char const str[] = "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, - const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, + const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { PreCreateCommandBuffer(device, pCreateInfo); - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); PostCreateCommandBuffer(result, pCmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { char str[1024]; if (!pBeginInfo) { @@ -1141,25 +1141,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co sprintf(str, "Parameter pBeginInfo to function BeginCommandBuffer contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1169,7 +1169,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { char str[1024]; if (!validate_VK_STATE_BIND_POINT(stateBindPoint)) { @@ -1179,7 +1179,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData) +VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1189,13 +1189,13 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { char str[1024]; if (!validate_VK_INDEX_TYPE(indexType)) { @@ -1205,43 +1205,43 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFF nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) { nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) { nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z) +VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) { nextTable.CmdDispatch(cmdBuffer, x, y, z); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { char str[1024]; uint32_t i; @@ -1254,7 +1254,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1275,7 +1275,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcI nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1296,7 +1296,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcI nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) { @@ -1313,7 +1313,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BU nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1330,7 +1330,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1344,19 +1344,19 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(imageLayout)) { @@ -1373,7 +1373,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAG nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(imageLayout)) { @@ -1390,7 +1390,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t rectCount, const VkImageResolve* pRects) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1411,7 +1411,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE s nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { char str[1024]; if (!validate_VK_PIPE_EVENT(pipeEvent)) { @@ -1421,7 +1421,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { char str[1024]; if (!validate_VK_PIPE_EVENT(pipeEvent)) { @@ -1431,7 +1431,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT eve nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo) +VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo) { char str[1024]; if (!pWaitInfo) { @@ -1445,7 +1445,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVE nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); } -VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier) +VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier) { char str[1024]; if (!pBarrier) { @@ -1459,25 +1459,25 @@ VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset) { char str[1024]; if (!validate_VK_TIMESTAMP_TYPE(timestampType)) { @@ -1487,7 +1487,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMES nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1497,7 +1497,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset) +VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1507,7 +1507,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1517,7 +1517,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { char str[1024]; if (!pCreateInfo) { @@ -1528,16 +1528,16 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_F sprintf(str, "Parameter pCreateInfo to function CreateFramebuffer contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); return result; } -void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo) +void PreCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo) { if(pCreateInfo == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS_CREATE_INFO* pCreateInfo, is "\ + char const str[] = "vkCreateRenderPass parameter, VkRenderPassCreateInfo* pCreateInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1553,7 +1553,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!vk_validate_vk_rect(&pCreateInfo->renderArea)) { - char const str[] = "vkCreateRenderPass parameter, VK_RECT pCreateInfo->renderArea, is invalid "\ + char const str[] = "vkCreateRenderPass parameter, VkRect pCreateInfo->renderArea, is invalid "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1561,7 +1561,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!vk_validate_vk_extent2d(&pCreateInfo->extent)) { - char const str[] = "vkCreateRenderPass parameter, VK_EXTENT2D pCreateInfo->extent, is invalid "\ + char const str[] = "vkCreateRenderPass parameter, VkExtent2D pCreateInfo->extent, is invalid "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1569,7 +1569,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorFormats == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT* pCreateInfo->pColorFormats, "\ + char const str[] = "vkCreateRenderPass parameter, VkFormat* pCreateInfo->pColorFormats, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1580,20 +1580,20 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_FORMAT(pCreateInfo->pColorFormats[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i << + ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; } - VK_FORMAT_PROPERTIES properties; + VkFormatProperties properties; size_t size = sizeof(properties); - VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i], + VkResult result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i], VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties); if(result != VK_SUCCESS) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i << + ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], cannot be validated (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1602,7 +1602,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i << + ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], contains unsupported format (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1612,7 +1612,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorLayouts == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT* pCreateInfo->pColorLayouts, "\ + char const str[] = "vkCreateRenderPass parameter, VkImageLayout* pCreateInfo->pColorLayouts, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1623,7 +1623,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->pColorLayouts[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->pColorLayouts[" << i << + ss << "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pColorLayouts[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1632,7 +1632,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorLoadOps == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP* pCreateInfo->pColorLoadOps, "\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1643,7 +1643,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->pColorLoadOps[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->pColorLoadOps[" << i << + ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->pColorLoadOps[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1652,7 +1652,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorStoreOps == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1663,7 +1663,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i << + ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->pColorStoreOps[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1672,7 +1672,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorLoadClearValues == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_CLEAR_COLOR* pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkClearColor* pCreateInfo->"\ "pColorLoadClearValues, is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1711,7 +1711,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!vk_validate_vk_clear_color(&(pCreateInfo->pColorLoadClearValues[i]))) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_CLEAR_COLOR pCreateInfo->pColorLoadClearValues[" << i << + ss << "vkCreateRenderPass parameter, VkClearColor pCreateInfo->pColorLoadClearValues[" << i << "], is invalid (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1720,19 +1720,19 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_FORMAT(pCreateInfo->depthStencilFormat)) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->"\ "depthStencilFormat, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } - VK_FORMAT_PROPERTIES properties; + VkFormatProperties properties; size_t size = sizeof(properties); - VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat, + VkResult result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat, VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties); if(result != VK_SUCCESS) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->"\ "depthStencilFormat, cannot be validated (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1740,7 +1740,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->"\ "depthStencilFormat, contains unsupported format (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1748,7 +1748,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->depthStencilLayout)) { - char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->"\ "depthStencilLayout, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1756,7 +1756,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->depthLoadOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->"\ "depthLoadOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1764,7 +1764,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->depthStoreOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->"\ "depthStoreOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1772,7 +1772,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->stencilLoadOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->"\ "stencilLoadOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1780,18 +1780,18 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->stencilStoreOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->"\ "stencilStoreOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -void PostCreateRenderPass(VK_RESULT result, VK_RENDER_PASS* pRenderPass) +void PostCreateRenderPass(VkResult result, VkRenderPass* pRenderPass) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateRenderPass failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1799,21 +1799,21 @@ void PostCreateRenderPass(VK_RESULT result, VK_RENDER_PASS* pRenderPass) if(pRenderPass == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS* pRenderPass, is nullptr (postcondition)."; + char const str[] = "vkCreateRenderPass parameter, VkRenderPass* pRenderPass, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass) +VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { PreCreateRenderPass(device, pCreateInfo); - VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); PostCreateRenderPass(result, pRenderPass); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin) +VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) { char str[1024]; if (!pRenderPassBegin) { @@ -1827,24 +1827,24 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); } -VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass) +VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass) { nextTable.CmdEndRenderPass(cmdBuffer, renderPass); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetValidationLevel(VkDevice device, VkValidationLevel validationLevel) { char str[1024]; if (!validate_VK_VALIDATION_LEVEL(validationLevel)) { sprintf(str, "Parameter validationLevel to function DbgSetValidationLevel has invalid value of %i.", (int)validationLevel); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel); + VkResult result = nextTable.DbgSetValidationLevel(device, validationLevel); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE)); @@ -1858,11 +1858,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav; @@ -1884,45 +1884,45 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, else g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK)); } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter) { - VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter); + VkResult result = nextTable.DbgSetMessageFilter(device, msgCode, filter); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkBaseObject object, size_t tagSize, const void* pTag) { - VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag); + VkResult result = nextTable.DbgSetObjectTag(object, tagSize, pTag); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetGlobalOption(VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) { - VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetDeviceOption(VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) { - VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker) { nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker); } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) { nextTable.CmdDbgMarkerEnd(cmdBuffer); @@ -1930,41 +1930,41 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) #if defined(__linux__) || defined(XCB_NVIDIA) -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo); + VkResult result = nextTable.WsiX11AssociateConnection((VkPhysicalGpu)gpuw->nextObject, pConnectionInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11GetMSC(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) { - VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); + VkResult result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); + VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence) { - VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); + VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); return result; } #endif #include "vk_generic_intercept_proc_helper.h" -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; void* addr; @@ -1979,7 +1979,7 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } diff --git a/loader/loader.c b/loader/loader.c index af88c415..b314ccb9 100644 --- a/loader/loader.c +++ b/loader/loader.c @@ -79,12 +79,12 @@ struct loader_icd { struct loader_scanned_icds { loader_platform_dl_handle handle; - vkGetProcAddrType GetProcAddr; - vkCreateInstanceType CreateInstance; - vkDestroyInstanceType DestroyInstance; - vkEnumerateGpusType EnumerateGpus; - vkGetExtensionSupportType GetExtensionSupport; - VK_INSTANCE instance; + PFN_vkGetProcAddr GetProcAddr; + PFN_vkCreateInstance CreateInstance; + PFN_vkDestroyInstance DestroyInstance; + PFN_vkEnumerateGpus EnumerateGpus; + PFN_vkGetExtensionSupport GetExtensionSupport; + VkInstance instance; struct loader_scanned_icds *next; }; @@ -274,7 +274,7 @@ static void loader_scanned_icd_add(const char *filename) } #define LOOKUP(func_ptr, func) do { \ - func_ptr = (vk ##func## Type) loader_platform_get_proc_address(handle, "vk" #func); \ + func_ptr = (PFN_vk ##func) loader_platform_get_proc_address(handle, "vk" #func); \ if (!func_ptr) { \ loader_log(VK_DBG_MSG_WARNING, 0, loader_platform_get_proc_address_error("vk" #func)); \ return; \ @@ -515,7 +515,7 @@ static void layer_lib_scan(void) loader.layer_scanned = true; } -static void loader_init_dispatch_table(VK_LAYER_DISPATCH_TABLE *tab, vkGetProcAddrType fpGPA, VK_PHYSICAL_GPU gpu) +static void loader_init_dispatch_table(VK_LAYER_DISPATCH_TABLE *tab, PFN_vkGetProcAddr fpGPA, VkPhysicalGpu gpu) { loader_initialize_dispatch_table(tab, fpGPA, gpu); @@ -578,12 +578,12 @@ static void loader_init_layer_libs(struct loader_icd *icd, uint32_t gpu_index, s } } -static VK_RESULT find_layer_extension(struct loader_icd *icd, uint32_t gpu_index, const char *pExtName, const char **lib_name) +static VkResult find_layer_extension(struct loader_icd *icd, uint32_t gpu_index, const char *pExtName, const char **lib_name) { - VK_RESULT err; + VkResult err; char *search_name; loader_platform_dl_handle handle; - vkGetExtensionSupportType fpGetExtensionSupport; + PFN_vkGetExtensionSupport fpGetExtensionSupport; /* * The loader provides the abstraction that make layers and extensions work via @@ -596,7 +596,7 @@ static VK_RESULT find_layer_extension(struct loader_icd *icd, uint32_t gpu_index // TODO: What if extension is in multiple places? // TODO: Who should we ask first? Driver or layers? Do driver for now. - err = icd->scanned_icds[gpu_index].GetExtensionSupport((VK_PHYSICAL_GPU) (icd->gpus[gpu_index].nextObject), pExtName); + err = icd->scanned_icds[gpu_index].GetExtensionSupport((VkPhysicalGpu) (icd->gpus[gpu_index].nextObject), pExtName); if (err == VK_SUCCESS) { if (lib_name) { *lib_name = NULL; @@ -614,7 +614,7 @@ static VK_RESULT find_layer_extension(struct loader_icd *icd, uint32_t gpu_index if (fpGetExtensionSupport != NULL) { // Found layer's GetExtensionSupport call - err = fpGetExtensionSupport((VK_PHYSICAL_GPU) (icd->gpus + gpu_index), pExtName); + err = fpGetExtensionSupport((VkPhysicalGpu) (icd->gpus + gpu_index), pExtName); loader_platform_close_library(handle); @@ -788,7 +788,7 @@ static void loader_deactivate_layer(const struct loader_instance *instance) } } -extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo) +extern uint32_t loader_activate_layers(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo) { uint32_t gpu_index; uint32_t count; @@ -803,7 +803,7 @@ extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreate if (!loader_layers_activated(icd, gpu_index)) { VK_BASE_LAYER_OBJECT *gpuObj = (VK_BASE_LAYER_OBJECT *) gpu; VK_BASE_LAYER_OBJECT *nextGpuObj, *baseObj = gpuObj->baseObject; - vkGetProcAddrType nextGPA = vkGetProcAddr; + PFN_vkGetProcAddr nextGPA = vkGetProcAddr; count = loader_get_layer_libs(icd, gpu_index, pCreateInfo, &pLayerNames); if (!count) @@ -822,8 +822,8 @@ extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreate char funcStr[256]; snprintf(funcStr, 256, "%sGetProcAddr",icd->layer_libs[gpu_index][i].name); - if ((nextGPA = (vkGetProcAddrType) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, funcStr)) == NULL) - nextGPA = (vkGetProcAddrType) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, "vkGetProcAddr"); + if ((nextGPA = (PFN_vkGetProcAddr) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, funcStr)) == NULL) + nextGPA = (PFN_vkGetProcAddr) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, "vkGetProcAddr"); if (!nextGPA) { loader_log(VK_DBG_MSG_ERROR, 0, "Failed to find vkGetProcAddr in layer %s", icd->layer_libs[gpu_index][i].name); continue; @@ -857,16 +857,16 @@ extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreate return icd->layer_count[gpu_index]; } -LOADER_EXPORT VK_RESULT VKAPI vkCreateInstance( +LOADER_EXPORT VkResult VKAPI vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, - VK_INSTANCE* pInstance) + VkInstance* pInstance) { static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_icd); static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_layer); struct loader_instance *ptr_instance = NULL; struct loader_scanned_icds *scanned_icds; struct loader_icd *icd; - VK_RESULT res = VK_ERROR_INITIALIZATION_FAILED; + VkResult res = VK_ERROR_INITIALIZATION_FAILED; /* Scan/discover all ICD libraries in a single-threaded manner */ loader_platform_thread_once(&once_icd, loader_icd_scan); @@ -905,16 +905,16 @@ LOADER_EXPORT VK_RESULT VKAPI vkCreateInstance( return VK_ERROR_INCOMPATIBLE_DRIVER; } - *pInstance = (VK_INSTANCE) ptr_instance; + *pInstance = (VkInstance) ptr_instance; return VK_SUCCESS; } -LOADER_EXPORT VK_RESULT VKAPI vkDestroyInstance( - VK_INSTANCE instance) +LOADER_EXPORT VkResult VKAPI vkDestroyInstance( + VkInstance instance) { struct loader_instance *ptr_instance = (struct loader_instance *) instance; struct loader_scanned_icds *scanned_icds; - VK_RESULT res; + VkResult res; // Remove this instance from the list of instances: struct loader_instance *prev = NULL; @@ -955,24 +955,24 @@ LOADER_EXPORT VK_RESULT VKAPI vkDestroyInstance( return VK_SUCCESS; } -LOADER_EXPORT VK_RESULT VKAPI vkEnumerateGpus( +LOADER_EXPORT VkResult VKAPI vkEnumerateGpus( - VK_INSTANCE instance, + VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, - VK_PHYSICAL_GPU* pGpus) + VkPhysicalGpu* pGpus) { struct loader_instance *ptr_instance = (struct loader_instance *) instance; struct loader_icd *icd; uint32_t count = 0; - VK_RESULT res; + VkResult res; //in spirit of VK don't error check on the instance parameter icd = ptr_instance->icds; while (icd) { - VK_PHYSICAL_GPU gpus[VK_MAX_PHYSICAL_GPUS]; + VkPhysicalGpu gpus[VK_MAX_PHYSICAL_GPUS]; VK_BASE_LAYER_OBJECT * wrapped_gpus; - vkGetProcAddrType get_proc_addr = icd->scanned_icds->GetProcAddr; + PFN_vkGetProcAddr get_proc_addr = icd->scanned_icds->GetProcAddr; uint32_t n, max = maxGpus - count; if (max > VK_MAX_PHYSICAL_GPUS) { @@ -1024,7 +1024,7 @@ LOADER_EXPORT VK_RESULT VKAPI vkEnumerateGpus( return (count > 0) ? VK_SUCCESS : res; } -LOADER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char * pName) +LOADER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char * pName) { if (gpu == NULL) { return NULL; @@ -1046,7 +1046,7 @@ LOADER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char * pName } } -LOADER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char *pExtName) +LOADER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char *pExtName) { uint32_t gpu_index; struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index); @@ -1057,14 +1057,14 @@ LOADER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const c return find_layer_extension(icd, gpu_index, pExtName, NULL); } -LOADER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { uint32_t gpu_index; size_t count = 0; char *lib_name; struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index); loader_platform_dl_handle handle; - vkEnumerateLayersType fpEnumerateLayers; + PFN_vkEnumerateLayers fpEnumerateLayers; char layer_buf[16][256]; char * layers[16]; @@ -1108,7 +1108,7 @@ LOADER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxL } else { size_t cnt; uint32_t n; - VK_RESULT res; + VkResult res; n = (uint32_t) ((maxStringSize < 256) ? maxStringSize : 256); res = fpEnumerateLayers(NULL, 16, n, &cnt, layers, (char *) icd->gpus + gpu_index); loader_platform_close_library(handle); @@ -1130,11 +1130,11 @@ LOADER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxL return VK_SUCCESS; } -LOADER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +LOADER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { const struct loader_icd *icd; struct loader_instance *inst; - VK_RESULT res; + VkResult res; uint32_t gpu_idx; if (instance == VK_NULL_HANDLE) @@ -1181,9 +1181,9 @@ LOADER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_ return VK_SUCCESS; } -LOADER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +LOADER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { - VK_RESULT res = VK_SUCCESS; + VkResult res = VK_SUCCESS; struct loader_instance *inst; if (instance == VK_NULL_HANDLE) return VK_ERROR_INVALID_HANDLE; @@ -1200,7 +1200,7 @@ LOADER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, V for (const struct loader_icd * icd = inst->icds; icd; icd = icd->next) { for (uint32_t i = 0; i < icd->gpu_count; i++) { - VK_RESULT r; + VkResult r; r = (icd->loader_dispatch + i)->DbgUnregisterMsgCallback(icd->scanned_icds->instance, pfnMsgCallback); if (r != VK_SUCCESS) { res = r; @@ -1210,9 +1210,9 @@ LOADER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, V return res; } -LOADER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) +LOADER_EXPORT VkResult VKAPI vkDbgSetGlobalOption(VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) { - VK_RESULT res = VK_SUCCESS; + VkResult res = VK_SUCCESS; struct loader_instance *inst; if (instance == VK_NULL_HANDLE) return VK_ERROR_INVALID_HANDLE; @@ -1228,7 +1228,7 @@ LOADER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_ return VK_ERROR_INVALID_HANDLE; for (const struct loader_icd * icd = inst->icds; icd; icd = icd->next) { for (uint32_t i = 0; i < icd->gpu_count; i++) { - VK_RESULT r; + VkResult r; r = (icd->loader_dispatch + i)->DbgSetGlobalOption(icd->scanned_icds->instance, dbgOption, dataSize, pData); /* unfortunately we cannot roll back */ diff --git a/loader/loader.h b/loader/loader.h index f40a36a3..2967322b 100644 --- a/loader/loader.h +++ b/loader/loader.h @@ -65,16 +65,16 @@ static inline void loader_init_data(void *obj, const void *data) loader_set_data(obj, data); } -static inline void *loader_unwrap_gpu(VK_PHYSICAL_GPU *gpu) +static inline void *loader_unwrap_gpu(VkPhysicalGpu *gpu) { const VK_BASE_LAYER_OBJECT *wrap = (const VK_BASE_LAYER_OBJECT *) *gpu; - *gpu = (VK_PHYSICAL_GPU) wrap->nextObject; + *gpu = (VkPhysicalGpu) wrap->nextObject; return loader_get_data(wrap->baseObject); } -extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo); +extern uint32_t loader_activate_layers(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo); #define MAX_LAYER_LIBRARIES 64 #endif /* LOADER_H */ diff --git a/vk-generate.py b/vk-generate.py index 6cccd0c9..6591b1c9 100755 --- a/vk-generate.py +++ b/vk-generate.py @@ -156,7 +156,7 @@ class LoaderEntrypointsSubcommand(Subcommand): # declare local variables func.append(" const VK_LAYER_DISPATCH_TABLE *disp;") if proto.ret != 'void' and obj_setup: - func.append(" VK_RESULT res;") + func.append(" VkResult res;") func.append("") # active layers before dispatching CreateDevice @@ -168,7 +168,7 @@ class LoaderEntrypointsSubcommand(Subcommand): # get dispatch table and unwrap GPUs for param in proto.params: stmt = "" - if param.ty == "VK_PHYSICAL_GPU": + if param.ty == "VkPhysicalGpu": stmt = "loader_unwrap_gpu(&%s);" % param.name if param == proto.params[0]: stmt = "disp = " + stmt @@ -230,16 +230,16 @@ class DispatchTableOpsSubcommand(Subcommand): stmts.append("table->%s = gpa; /* direct assignment */" % proto.name) else: - stmts.append("table->%s = (vk%sType) gpa(gpu, \"vk%s\");" % + stmts.append("table->%s = (PFN_vk%s) gpa(gpu, \"vk%s\");" % (proto.name, proto.name, proto.name)) stmts.append("#endif") func = [] func.append("static inline void %s_initialize_dispatch_table(VK_LAYER_DISPATCH_TABLE *table," % self.prefix) - func.append("%s vkGetProcAddrType gpa," + func.append("%s PFN_vkGetProcAddr gpa," % (" " * len(self.prefix))) - func.append("%s VK_PHYSICAL_GPU gpu)" + func.append("%s VkPhysicalGpu gpu)" % (" " * len(self.prefix))) func.append("{") func.append(" %s" % "\n ".join(stmts)) diff --git a/vk-layer-generate.py b/vk-layer-generate.py index ec8a97c7..c924cfd9 100755 --- a/vk-layer-generate.py +++ b/vk-layer-generate.py @@ -134,7 +134,7 @@ class Subcommand(object): return ("%i", "*(%s)" % name) return ("%i", name) # TODO : This is special-cased as there's only one "format" param currently and it's nice to expand it - if "VK_FORMAT" == vk_type: + if "VkFormat" == vk_type: if cpp: return ("%p", "&%s" % name) return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_CHANNEL_FORMAT(%s.channelFormat), string_VK_NUM_FORMAT(%s.numericFormat)" % (name, name)) @@ -146,7 +146,7 @@ class Subcommand(object): def _gen_layer_dbg_callback_register(self): r_body = [] - r_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)') + r_body.append('VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)') r_body.append('{') r_body.append(' // This layer intercepts callbacks') r_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));') @@ -160,14 +160,14 @@ class Subcommand(object): r_body.append(' if (g_actionIsDefault) {') r_body.append(' g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;') r_body.append(' }') - r_body.append(' VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);') + r_body.append(' VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);') r_body.append(' return result;') r_body.append('}') return "\n".join(r_body) def _gen_layer_dbg_callback_unregister(self): ur_body = [] - ur_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)') + ur_body.append('VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)') ur_body.append('{') ur_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;') ur_body.append(' VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;') @@ -189,16 +189,16 @@ class Subcommand(object): ur_body.append(' else') ur_body.append(' g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK;') ur_body.append(' }') - ur_body.append(' VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);') + ur_body.append(' VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);') ur_body.append(' return result;') ur_body.append('}') return "\n".join(ur_body) def _gen_layer_get_extension_support(self, layer="Generic"): ges_body = [] - ges_body.append('VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)') + ges_body.append('VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)') ges_body.append('{') - ges_body.append(' VK_RESULT result;') + ges_body.append(' VkResult result;') ges_body.append(' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;') ges_body.append('') ges_body.append(' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */') @@ -207,7 +207,7 @@ class Subcommand(object): ges_body.append(' result = VK_SUCCESS;') ges_body.append(' } else if (nextTable.GetExtensionSupport != NULL)') ges_body.append(' {') - ges_body.append(' result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);') + ges_body.append(' result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName);') ges_body.append(' } else') ges_body.append(' {') ges_body.append(' result = VK_ERROR_INVALID_EXTENSION;') @@ -270,7 +270,7 @@ class Subcommand(object): exts.append(' return (type == VK_OBJECT_TYPE_ANY) ? numTotalObjs : numObjs[type];') exts.append('}') exts.append('') - exts.append('VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray)') + exts.append('VkResult objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray)') exts.append('{') exts.append(" // This bool flags if we're pulling all objs or just a single class of objs") exts.append(' bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY);') @@ -300,7 +300,7 @@ class Subcommand(object): def _generate_layer_gpa_function(self, extensions=[]): func_body = [] - func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)\n" + func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)\n" "{\n" " VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;\n" " void* addr;\n" @@ -319,7 +319,7 @@ class Subcommand(object): func_body.append(" else {\n" " if (gpuw->pGPA == NULL)\n" " return NULL;\n" - " return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);\n" + " return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName);\n" " }\n" "}\n") return "\n".join(func_body) @@ -345,11 +345,11 @@ class Subcommand(object): func_body.append(' g_logFile = stdout;') func_body.append(' }') func_body.append('') - func_body.append(' vkGetProcAddrType fpNextGPA;\n' + func_body.append(' PFN_vkGetProcAddr fpNextGPA;\n' ' fpNextGPA = pCurObj->pGPA;\n' ' assert(fpNextGPA);\n') - func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);") + func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject);") if lockname is not None: func_body.append(" if (!%sLockInitialized)" % lockname) func_body.append(" {") @@ -364,11 +364,11 @@ class Subcommand(object): func_body = ["#include \"vk_dispatch_table_helper.h\""] func_body.append('static void init%s(void)\n' '{\n' - ' vkGetProcAddrType fpNextGPA;\n' + ' PFN_vkGetProcAddr fpNextGPA;\n' ' fpNextGPA = pCurObj->pGPA;\n' ' assert(fpNextGPA);\n' % self.layer_name); - func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);\n") + func_body.append(" layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject);\n") func_body.append(" if (!printLockInitialized)") func_body.append(" {") func_body.append(" // TODO/TBD: Need to delete this mutex sometime. How???") @@ -406,12 +406,12 @@ class GenericLayerSubcommand(Subcommand): stmt = '' funcs = [] if proto.ret != "void": - ret_val = "VK_RESULT result = " + ret_val = "VkResult result = " stmt = " return result;\n" if 'WsiX11AssociateConnection' == proto.name: funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") if proto.name == "EnumerateLayers": - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) funcs.append('%s%s\n' '{\n' ' char str[1024];\n' @@ -435,14 +435,14 @@ class GenericLayerSubcommand(Subcommand): ' return VK_SUCCESS;\n' ' }\n' '}' % (qual, decl, proto.params[0].name, proto.name, self.layer_name, ret_val, c_call, proto.name, stmt, self.layer_name)) - elif proto.params[0].ty != "VK_PHYSICAL_GPU": + elif proto.params[0].ty != "VkPhysicalGpu": funcs.append('%s%s\n' '{\n' ' %snextTable.%s;\n' '%s' '}' % (qual, decl, ret_val, proto.c_call(), stmt)) else: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) funcs.append('%s%s\n' '{\n' ' char str[1024];' @@ -586,10 +586,10 @@ class APIDumpSubcommand(Subcommand): func_body.append('') func_body.append(' ConfigureOutputStream(writeToFile, flushAfterWrite);') func_body.append('') - func_body.append(' vkGetProcAddrType fpNextGPA;') + func_body.append(' PFN_vkGetProcAddr fpNextGPA;') func_body.append(' fpNextGPA = pCurObj->pGPA;') func_body.append(' assert(fpNextGPA);') - func_body.append(' layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);') + func_body.append(' layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject);') func_body.append('') func_body.append(' if (!printLockInitialized)') func_body.append(' {') @@ -614,7 +614,7 @@ class APIDumpSubcommand(Subcommand): elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name: create_params = -1 if proto.ret != "void": - ret_val = "VK_RESULT result = " + ret_val = "VkResult result = " stmt = " return result;\n" f_open = 'loader_platform_thread_lock_mutex(&printLock);\n ' log_func = ' if (StreamControl::writeAddress == true) {' @@ -653,8 +653,8 @@ class APIDumpSubcommand(Subcommand): log_func = log_func.strip(', ') log_func_no_addr = log_func_no_addr.strip(', ') if proto.ret != "void": - log_func += ') = " << string_VK_RESULT((VK_RESULT)result) << endl' - log_func_no_addr += ') = " << string_VK_RESULT((VK_RESULT)result) << endl' + log_func += ') = " << string_VkResult((VkResult)result) << endl' + log_func_no_addr += ') = " << string_VkResult((VkResult)result) << endl' else: log_func += ')\\n"' log_func_no_addr += ')\\n"' @@ -697,7 +697,7 @@ class APIDumpSubcommand(Subcommand): if 'WsiX11AssociateConnection' == proto.name: funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") if proto.name == "EnumerateLayers": - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) funcs.append('%s%s\n' '{\n' ' using namespace StreamControl;\n' @@ -718,11 +718,11 @@ class APIDumpSubcommand(Subcommand): ' }\n' '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call,f_open, log_func, f_close, stmt, self.layer_name)) elif 'GetExtensionSupport' == proto.name: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) funcs.append('%s%s\n' '{\n' ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' VK_RESULT result;\n' + ' VkResult result;\n' ' /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n' ' if (!strncmp(pExtName, "%s", strlen("%s")))\n' ' {\n' @@ -737,7 +737,7 @@ class APIDumpSubcommand(Subcommand): ' }\n' '%s' '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, c_call, f_open, log_func, f_close, stmt)) - elif proto.params[0].ty != "VK_PHYSICAL_GPU": + elif proto.params[0].ty != "VkPhysicalGpu": funcs.append('%s%s\n' '{\n' ' using namespace StreamControl;\n' @@ -746,7 +746,7 @@ class APIDumpSubcommand(Subcommand): '%s' '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt)) else: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) funcs.append('%s%s\n' '{\n' ' using namespace StreamControl;\n' @@ -879,7 +879,7 @@ class ObjectTrackerSubcommand(Subcommand): header_txt.append(' if (0) ll_print_lists();') header_txt.append('}') header_txt.append('// Traverse global list and return type for given object') - header_txt.append('static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) {') + header_txt.append('static VK_OBJECT_TYPE ll_get_obj_type(VkObject object) {') header_txt.append(' objNode *pTrav = pGlobalHead;') header_txt.append(' while (pTrav) {') header_txt.append(' if (pTrav->obj.pObj == object)') @@ -1067,7 +1067,7 @@ class ObjectTrackerSubcommand(Subcommand): header_txt.append('}') header_txt.append('') header_txt.append('static void setGpuQueueInfoState(void *pData) {') - header_txt.append(' maxMemReferences = ((VK_PHYSICAL_GPU_QUEUE_PROPERTIES *)pData)->maxMemReferences;') + header_txt.append(' maxMemReferences = ((VkPhysicalGpu_QUEUE_PROPERTIES *)pData)->maxMemReferences;') header_txt.append('}') return "\n".join(header_txt) @@ -1077,7 +1077,7 @@ class ObjectTrackerSubcommand(Subcommand): return None obj_type_mapping = {base_t : base_t.replace("VK_", "VK_OBJECT_TYPE_") 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"]: + for obj_type in ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT", "VkObject", "VkBaseObject"]: obj_type_mapping[obj_type] = "ll_get_obj_type(object)" decl = proto.c_func(prefix="vk", attr="VKAPI") @@ -1157,12 +1157,12 @@ class ObjectTrackerSubcommand(Subcommand): ret_val = '' stmt = '' if proto.ret != "void": - ret_val = "VK_RESULT result = " + ret_val = "VkResult result = " stmt = " return result;\n" if 'WsiX11AssociateConnection' == proto.name: funcs.append("#if defined(__linux__) || defined(XCB_NVIDIA)") if proto.name == "EnumerateLayers": - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) funcs.append('%s%s\n' '{\n' ' if (gpu != NULL) {\n' @@ -1183,11 +1183,11 @@ class ObjectTrackerSubcommand(Subcommand): ' }\n' '}' % (qual, decl, proto.params[0].name, using_line, self.layer_name, ret_val, c_call, create_line, destroy_line, stmt, self.layer_name)) elif 'GetExtensionSupport' == proto.name: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) funcs.append('%s%s\n' '{\n' ' VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n' - ' VK_RESULT result;\n' + ' VkResult result;\n' ' /* This entrypoint is NOT going to init its own dispatch table since loader calls this early */\n' ' if (!strncmp(pExtName, "%s", strlen("%s")) ||\n' ' !strncmp(pExtName, "objTrackGetObjectCount", strlen("objTrackGetObjectCount")) ||\n' @@ -1204,7 +1204,7 @@ class ObjectTrackerSubcommand(Subcommand): ' }\n' '%s' '}' % (qual, decl, proto.params[0].name, self.layer_name, self.layer_name, using_line, c_call, stmt)) - elif proto.params[0].ty != "VK_PHYSICAL_GPU": + elif proto.params[0].ty != "VkPhysicalGpu": funcs.append('%s%s\n' '{\n' '%s' @@ -1213,7 +1213,7 @@ class ObjectTrackerSubcommand(Subcommand): '%s' '}' % (qual, decl, using_line, ret_val, proto.c_call(), create_line, destroy_line, stmt)) else: - c_call = proto.c_call().replace("(" + proto.params[0].name, "((VK_PHYSICAL_GPU)gpuw->nextObject", 1) + c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1) gpu_state = '' if 'GetGpuInfo' in proto.name: gpu_state = ' if (infoType == VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES) {\n' diff --git a/vk_helper.py b/vk_helper.py index f8cf2a80..88951735 100755 --- a/vk_helper.py +++ b/vk_helper.py @@ -298,26 +298,20 @@ def recreate_structs(): sys.stdout.write(";\n\n") # +# TODO: Fix construction of struct name def get_struct_name_from_struct_type(struct_type): + # Note: All struct types are now camel-case caps_struct_name = struct_type.replace("_STRUCTURE_TYPE", "") - # NOTE: These must stay in caps as they are looking at the VK_STRUCTURE_TYPE_*_CREATE_INFO - # and that has not changed to camel case - exceptions_list = ['VK_DEVICE_CREATE_INFO', 'VK_INSTANCE_CREATE_INFO', 'VK_LAYER_CREATE_INFO', - 'VK_MEMORY_ALLOC_INFO', 'VK_MEMORY_ALLOC_BUFFER_INFO', 'VK_MEMORY_ALLOC_IMAGE_INFO', - 'VK_BUFFER_CREATE_INFO', 'VK_BUFFER_VIEW_CREATE_INFO'] - if caps_struct_name in exceptions_list: - char_idx = 0 - struct_name = '' - for char in caps_struct_name: - if (0 == char_idx) or (caps_struct_name[char_idx-1] == '_'): - struct_name += caps_struct_name[char_idx] - elif (caps_struct_name[char_idx] == '_'): - pass - else: - struct_name += caps_struct_name[char_idx].lower() - char_idx += 1 - else: - struct_name = caps_struct_name + char_idx = 0 + struct_name = '' + for char in caps_struct_name: + if (0 == char_idx) or (caps_struct_name[char_idx-1] == '_'): + struct_name += caps_struct_name[char_idx] + elif (caps_struct_name[char_idx] == '_'): + pass + else: + struct_name += caps_struct_name[char_idx].lower() + char_idx += 1 return struct_name # class for writing common file elements @@ -526,11 +520,11 @@ class StructWrapperGen: def _generateDynamicPrintFunctions(self): dp_funcs = [] dp_funcs.append("\nvoid dynamic_display_full_txt(const void* pStruct, uint32_t indent)\n{\n // Cast to APP_INFO ptr initially just to pull sType off struct") - dp_funcs.append(" VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;\n") + dp_funcs.append(" VkStructureType sType = ((VkApplicationInfo*)pStruct)->sType;\n") dp_funcs.append(" switch (sType)\n {") for e in enum_type_dict: class_num = 0 - if "_STRUCTURE_TYPE" in e: + if "StructureType" in e: for v in sorted(enum_type_dict[e]): struct_name = get_struct_name_from_struct_type(v) class_name = self.get_class_name(struct_name) @@ -592,14 +586,14 @@ class StructWrapperGen: member_post = ' ? "TRUE" : "FALSE"' elif 'float' in struct_member['type']: print_type = "f" - elif 'uint64' in struct_member['type']: - print_type = "lu" + elif 'uint64' in struct_member['type'] or 'gpusize' in struct_member['type'].lower(): + print_type = '" PRId64 "' elif 'uint8' in struct_member['type']: print_type = "hu" - elif '_size' in struct_member['type']: + elif 'size' in struct_member['type'].lower(): print_type = '" PRINTF_SIZE_T_SPECIFIER "' print_delimiter = "" - elif True in [ui_str.lower() in struct_member['type'].lower() for ui_str in ['uint', '_FLAGS', '_SAMPLE_MASK']]: + elif True in [ui_str.lower() in struct_member['type'].lower() for ui_str in ['uint', 'flags', 'samplemask']]: print_type = "u" elif 'int' in struct_member['type']: print_type = "i" @@ -723,11 +717,11 @@ class StructWrapperGen: sh_funcs.append(" if (pStruct == NULL) {") sh_funcs.append(" return NULL;") sh_funcs.append(" }") - sh_funcs.append(" VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;") + sh_funcs.append(" VkStructureType sType = ((VkApplicationInfo*)pStruct)->sType;") sh_funcs.append(' char indent[100];\n strcpy(indent, " ");\n strcat(indent, prefix);') sh_funcs.append(" switch (sType)\n {") for e in enum_type_dict: - if "_STRUCTURE_TYPE" in e: + if "StructureType" in e: for v in sorted(enum_type_dict[e]): struct_name = get_struct_name_from_struct_type(v) print_func_name = self._get_sh_func_name(struct_name) @@ -750,6 +744,7 @@ class StructWrapperGen: # create and return final string sh_funcs = [] # First generate prototypes for every struct + # XXX - REMOVE this comment for s in sorted(self.struct_dict): sh_funcs.append('string %s(const %s* pStruct, const string prefix);' % (self._get_sh_func_name(s), typedef_fwd_dict[s])) sh_funcs.append('\n') @@ -892,22 +887,23 @@ class StructWrapperGen: sh_funcs.append(" if (pStruct == NULL) {\n") sh_funcs.append(" return NULL;") sh_funcs.append(" }\n") - sh_funcs.append(" VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;") + sh_funcs.append(" VkStructureType sType = ((VkApplicationInfo*)pStruct)->sType;") sh_funcs.append(' string indent = " ";') sh_funcs.append(' indent += prefix;') sh_funcs.append(" switch (sType)\n {") for e in enum_type_dict: - if "_STRUCTURE_TYPE" in e: + if "StructureType" in e: for v in sorted(enum_type_dict[e]): struct_name = get_struct_name_from_struct_type(v) print_func_name = self._get_sh_func_name(struct_name) + #sh_funcs.append('string %s(const %s* pStruct, const string prefix);' % (self._get_sh_func_name(s), typedef_fwd_dict[s])) sh_funcs.append(' case %s:\n {' % (v)) sh_funcs.append(' return %s((%s*)pStruct, indent);' % (print_func_name, struct_name)) sh_funcs.append(' }') sh_funcs.append(' break;') sh_funcs.append(" default:") sh_funcs.append(" return NULL;") - sh_funcs.append(" }") + sh_funcs.append(" }") sh_funcs.append("}") return "\n".join(sh_funcs) @@ -1056,7 +1052,7 @@ class StructWrapperGen: for s in sorted(self.struct_dict): sh_funcs.append('uint32_t %s(const %s* pStruct)\n{' % (self._get_vh_func_name(s), typedef_fwd_dict[s])) for m in sorted(self.struct_dict[s]): - # TODO : Need to handle arrays of enums like in VK_RENDER_PASS_CREATE_INFO struct + # TODO : Need to handle arrays of enums like in VkRenderPassCreateInfo struct if is_type(self.struct_dict[s][m]['type'], 'enum') and not self.struct_dict[s][m]['ptr']: sh_funcs.append(' if (!validate_%s(pStruct->%s))\n return 0;' % (self.struct_dict[s][m]['type'], self.struct_dict[s][m]['name'])) # TODO : Need a little refinement to this code to make sure type of struct matches expected input (ptr, const...) @@ -1107,7 +1103,7 @@ class StructWrapperGen: if not is_type(self.struct_dict[s][m]['type'], 'struct') and not 'char' in self.struct_dict[s][m]['type'].lower(): if 'ppMemBarriers' == self.struct_dict[s][m]['name']: # TODO : For now be conservative and consider all memBarrier ptrs as largest possible struct - sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(VK_IMAGE_MEMORY_BARRIER));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type'])) + sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(VkImageMemoryBarrier));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type'])) else: sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(%s));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type'], self.struct_dict[s][m]['type'])) else: # This is an array of char* or array of struct ptrs @@ -1154,8 +1150,8 @@ class StructWrapperGen: else: sh_funcs.append('size_t get_dynamic_struct_size(const void* pStruct)\n{') indent = ' ' - sh_funcs.append('%s// Just use VK_APPLICATION_INFO as struct until actual type is resolved' % (indent)) - sh_funcs.append('%sVK_APPLICATION_INFO* pNext = (VK_APPLICATION_INFO*)pStruct;' % (indent)) + sh_funcs.append('%s// Just use VkApplicationInfo as struct until actual type is resolved' % (indent)) + sh_funcs.append('%sVkApplicationInfo* pNext = (VkApplicationInfo*)pStruct;' % (indent)) sh_funcs.append('%ssize_t structSize = 0;' % (indent)) if follow_chain: sh_funcs.append('%swhile (pNext) {' % (indent)) @@ -1163,7 +1159,7 @@ class StructWrapperGen: sh_funcs.append('%sswitch (pNext->sType) {' % (indent)) indent += ' ' for e in enum_type_dict: - if '_STRUCTURE_TYPE' in e: + if 'StructureType' in e: for v in sorted(enum_type_dict[e]): struct_name = get_struct_name_from_struct_type(v) sh_funcs.append('%scase %s:' % (indent, v)) @@ -1181,7 +1177,7 @@ class StructWrapperGen: indent = indent[:-4] sh_funcs.append('%s}' % (indent)) if follow_chain: - sh_funcs.append('%spNext = (VK_APPLICATION_INFO*)pNext->pNext;' % (indent)) + sh_funcs.append('%spNext = (VkApplicationInfo*)pNext->pNext;' % (indent)) indent = indent[:-4] sh_funcs.append('%s}' % (indent)) sh_funcs.append('%sreturn structSize;\n}' % indent) @@ -1388,8 +1384,8 @@ class GraphVizGen: array_index = "" member_print_post = "" print_delimiter = "%" - if struct_member['array'] and 'CHAR' in struct_member['type']: # just print char array as string - print_type = "s" + if struct_member['array'] and 'char' in struct_member['type'].lower(): # just print char array as string + print_type = "p" print_array = False elif struct_member['array'] and not print_array: # Just print base address of array when not full print_array @@ -1408,14 +1404,14 @@ class GraphVizGen: member_post = ' ? "TRUE" : "FALSE"' elif 'float' in struct_member['type']: print_type = "f" - elif 'uint64' in struct_member['type']: - print_type = "lu" + elif 'uint64' in struct_member['type'] or 'gpusize' in struct_member['type'].lower(): + print_type = '" PRId64 "' elif 'uint8' in struct_member['type']: print_type = "hu" - elif '_SIZE' in struct_member['type']: + elif 'size' in struct_member['type'].lower(): print_type = '" PRINTF_SIZE_T_SPECIFIER "' print_delimiter = "" - elif True in [ui_str in struct_member['type'] for ui_str in ['uint', '_FLAGS', '_SAMPLE_MASK']]: + elif True in [ui_str.lower() in struct_member['type'].lower() for ui_str in ['uint', 'flags', 'samplemask']]: print_type = "u" elif 'int' in struct_member['type']: print_type = "i" @@ -1429,21 +1425,21 @@ class GraphVizGen: array_index = " i," member_post = "[i]" print_out = "%%s%s%s%s%s%s" % (member_name, member_print_post, port_label, print_delimiter, print_type, postfix) # section of print that goes inside of quotes - print_arg = ", %s,%s %s(%s%s%s)%s" % (pre_var_name, array_index, cast_type, struct_var_name, struct_op, member_name, member_post) # section of print passed to portion in quotes + print_arg = ", %s,%s %s(%s%s%s)%s\n" % (pre_var_name, array_index, cast_type, struct_var_name, struct_op, member_name, member_post) # section of print passed to portion in quotes return (print_out, print_arg) def _generateBody(self): gv_funcs = [] array_func_list = [] # structs for which we'll generate an array version of their print function - array_func_list.append('vk_buffer_view_attach_info') - array_func_list.append('vk_image_view_attach_info') - array_func_list.append('vk_sampler_image_view_info') - array_func_list.append('vk_descriptor_type_count') + array_func_list.append('vkbufferviewattachinfo') + array_func_list.append('vkimageviewattachinfo') + array_func_list.append('vksamplerimageviewinfo') + array_func_list.append('vkdescriptortypecount') # For first pass, generate prototype for s in sorted(self.struct_dict): gv_funcs.append('char* %s(const %s* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) if s.lower().strip("_") in array_func_list: - if s.lower().strip("_") in ['vk_buffer_view_attach_info', 'vk_image_view_attach_info']: + if s.lower().strip("_") in ['vkbufferviewattachinfo', 'vkimageviewattachinfo']: gv_funcs.append('char* %s_array(uint32_t count, const %s* const* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) else: gv_funcs.append('char* %s_array(uint32_t count, const %s* pStruct, const char* myNodeName);\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) @@ -1528,7 +1524,7 @@ class GraphVizGen: gv_funcs.append(" return str;\n}\n") if s.lower().strip("_") in array_func_list: ptr_array = False - if s.lower().strip("_") in ['vk_buffer_view_attach_info', 'vk_image_view_attach_info']: + if s.lower().strip("_") in ['vkbufferviewattachinfo', 'vkimageviewattachinfo']: ptr_array = True gv_funcs.append('char* %s_array(uint32_t count, const %s* const* pStruct, const char* myNodeName)\n{\n char* str;\n char tmpStr[1024];\n' % (self._get_gv_func_name(s), typedef_fwd_dict[s])) else: @@ -1562,21 +1558,21 @@ class GraphVizGen: # Add function to dynamically print out unknown struct gv_funcs.append("char* dynamic_gv_display(const void* pStruct, const char* nodeName)\n{\n") gv_funcs.append(" // Cast to APP_INFO ptr initially just to pull sType off struct\n") - gv_funcs.append(" VK_STRUCTURE_TYPE sType = ((VK_APPLICATION_INFO*)pStruct)->sType;\n") + gv_funcs.append(" VkStructureType sType = ((VkApplicationInfo*)pStruct)->sType;\n") gv_funcs.append(" switch (sType)\n {\n") for e in enum_type_dict: - if "_STRUCTURE_TYPE" in e: + if "StructureType" in e: for v in sorted(enum_type_dict[e]): struct_name = get_struct_name_from_struct_type(v) print_func_name = self._get_gv_func_name(struct_name) # TODO : Hand-coded fixes for some exceptions - #if 'VK_PIPELINE_CB_STATE_CREATE_INFO' in struct_name: + #if 'VkPipelineCbStateCreateInfo' in struct_name: # struct_name = 'VK_PIPELINE_CB_STATE' - if 'VK_SEMAPHORE_CREATE_INFO' in struct_name: - struct_name = 'VK_SEMAPHORE_CREATE_INFO' + if 'VkSemaphoreCreateInfo' in struct_name: + struct_name = 'VkSemaphoreCreateInfo' print_func_name = self._get_gv_func_name(struct_name) - elif 'VK_SEMAPHORE_OPEN_INFO' in struct_name: - struct_name = 'VK_SEMAPHORE_OPEN_INFO' + elif 'VkSemaphoreOpenInfo' in struct_name: + struct_name = 'VkSemaphoreOpenInfo' print_func_name = self._get_gv_func_name(struct_name) gv_funcs.append(' case %s:\n' % (v)) gv_funcs.append(' return %s((%s*)pStruct, nodeName);\n' % (print_func_name, struct_name)) @@ -1655,7 +1651,7 @@ def main(argv=None): if opts.gen_struct_wrappers: sw = StructWrapperGen(struct_dict, os.path.basename(opts.input_file).strip(".h"), os.path.dirname(enum_sh_filename)) #print(sw.get_class_name(struct)) - sw.set_include_headers([os.path.basename(opts.input_file),os.path.basename(enum_sh_filename),"stdint.h","stdio.h","stdlib.h"]) + sw.set_include_headers([os.path.basename(opts.input_file),os.path.basename(enum_sh_filename),"stdint.h","inttypes.h", "stdio.h","stdlib.h"]) print("Generating struct wrapper header to %s" % sw.header_filename) sw.generateHeader() print("Generating struct wrapper class to %s" % sw.class_filename) @@ -1679,7 +1675,7 @@ def main(argv=None): cmg.generate() if opts.gen_graphviz: gv = GraphVizGen(struct_dict, os.path.basename(opts.input_file).strip(".h"), os.path.dirname(enum_sh_filename)) - gv.set_include_headers([os.path.basename(opts.input_file),os.path.basename(enum_sh_filename),"stdint.h","stdio.h","stdlib.h"]) + gv.set_include_headers([os.path.basename(opts.input_file),os.path.basename(enum_sh_filename),"stdint.h","stdio.h","stdlib.h", "inttypes.h"]) gv.generate() print("DONE!") #print(typedef_rev_dict) diff --git a/vulkan.py b/vulkan.py index 28fcd7c9..07f431b6 100755 --- a/vulkan.py +++ b/vulkan.py @@ -183,460 +183,460 @@ core = Extension( name="VK_CORE", headers=["vulkan.h", "vkDbg.h"], objects=[ - "VK_INSTANCE", - "VK_PHYSICAL_GPU", - "VK_BASE_OBJECT", - "VK_DEVICE", - "VK_QUEUE", - "VK_GPU_MEMORY", - "VK_OBJECT", - "VK_BUFFER", - "VK_BUFFER_VIEW", - "VK_IMAGE", - "VK_IMAGE_VIEW", - "VK_COLOR_ATTACHMENT_VIEW", - "VK_DEPTH_STENCIL_VIEW", - "VK_SHADER", - "VK_PIPELINE", - "VK_SAMPLER", - "VK_DESCRIPTOR_SET", - "VK_DESCRIPTOR_SET_LAYOUT", - "VK_DESCRIPTOR_SET_LAYOUT_CHAIN", - "VK_DESCRIPTOR_POOL", - "VK_DYNAMIC_STATE_OBJECT", - "VK_DYNAMIC_VP_STATE_OBJECT", - "VK_DYNAMIC_RS_STATE_OBJECT", - "VK_DYNAMIC_CB_STATE_OBJECT", - "VK_DYNAMIC_DS_STATE_OBJECT", - "VK_CMD_BUFFER", - "VK_FENCE", - "VK_SEMAPHORE", - "VK_EVENT", - "VK_QUERY_POOL", - "VK_FRAMEBUFFER", - "VK_RENDER_PASS", + "VkInstance", + "VkPhysicalGpu", + "VkBaseObject", + "VkDevice", + "VkQueue", + "VkGpuMemory", + "VkObject", + "VkBuffer", + "VkBufferView", + "VkImage", + "VkImageView", + "VkColorAttachmentView", + "VkDepthStencilView", + "VkShader", + "VkPipeline", + "VkSampler", + "VkDescriptorSet", + "VkDescriptorSetLayout", + "VkDescriptorSetLayoutChain", + "VkDescriptorPool", + "VkDynamicStateObject", + "VkDynamicVpStateObject", + "VkDynamicRsStateObject", + "VkDynamicCbStateObject", + "VkDynamicDsStateObject", + "VkCmdBuffer", + "VkFence", + "VkSemaphore", + "VkEvent", + "VkQueryPool", + "VkFramebuffer", + "VkRenderPass", ], protos=[ - Proto("VK_RESULT", "CreateInstance", + Proto("VkResult", "CreateInstance", [Param("const VkInstanceCreateInfo*", "pCreateInfo"), - Param("VK_INSTANCE*", "pInstance")]), + Param("VkInstance*", "pInstance")]), - Proto("VK_RESULT", "DestroyInstance", - [Param("VK_INSTANCE", "instance")]), + Proto("VkResult", "DestroyInstance", + [Param("VkInstance", "instance")]), - Proto("VK_RESULT", "EnumerateGpus", - [Param("VK_INSTANCE", "instance"), + Proto("VkResult", "EnumerateGpus", + [Param("VkInstance", "instance"), Param("uint32_t", "maxGpus"), Param("uint32_t*", "pGpuCount"), - Param("VK_PHYSICAL_GPU*", "pGpus")]), + Param("VkPhysicalGpu*", "pGpus")]), - Proto("VK_RESULT", "GetGpuInfo", - [Param("VK_PHYSICAL_GPU", "gpu"), - Param("VK_PHYSICAL_GPU_INFO_TYPE", "infoType"), + Proto("VkResult", "GetGpuInfo", + [Param("VkPhysicalGpu", "gpu"), + Param("VkPhysicalGpuInfoType", "infoType"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), Proto("void*", "GetProcAddr", - [Param("VK_PHYSICAL_GPU", "gpu"), + [Param("VkPhysicalGpu", "gpu"), Param("const char*", "pName")]), - Proto("VK_RESULT", "CreateDevice", - [Param("VK_PHYSICAL_GPU", "gpu"), + Proto("VkResult", "CreateDevice", + [Param("VkPhysicalGpu", "gpu"), Param("const VkDeviceCreateInfo*", "pCreateInfo"), - Param("VK_DEVICE*", "pDevice")]), + Param("VkDevice*", "pDevice")]), - Proto("VK_RESULT", "DestroyDevice", - [Param("VK_DEVICE", "device")]), + Proto("VkResult", "DestroyDevice", + [Param("VkDevice", "device")]), - Proto("VK_RESULT", "GetExtensionSupport", - [Param("VK_PHYSICAL_GPU", "gpu"), + Proto("VkResult", "GetExtensionSupport", + [Param("VkPhysicalGpu", "gpu"), Param("const char*", "pExtName")]), - Proto("VK_RESULT", "EnumerateLayers", - [Param("VK_PHYSICAL_GPU", "gpu"), + Proto("VkResult", "EnumerateLayers", + [Param("VkPhysicalGpu", "gpu"), Param("size_t", "maxLayerCount"), Param("size_t", "maxStringSize"), Param("size_t*", "pOutLayerCount"), Param("char* const*", "pOutLayers"), Param("void*", "pReserved")]), - Proto("VK_RESULT", "GetDeviceQueue", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "GetDeviceQueue", + [Param("VkDevice", "device"), Param("uint32_t", "queueNodeIndex"), Param("uint32_t", "queueIndex"), - Param("VK_QUEUE*", "pQueue")]), + Param("VkQueue*", "pQueue")]), - Proto("VK_RESULT", "QueueSubmit", - [Param("VK_QUEUE", "queue"), + Proto("VkResult", "QueueSubmit", + [Param("VkQueue", "queue"), Param("uint32_t", "cmdBufferCount"), - Param("const VK_CMD_BUFFER*", "pCmdBuffers"), - Param("VK_FENCE", "fence")]), + Param("const VkCmdBuffer*", "pCmdBuffers"), + Param("VkFence", "fence")]), - Proto("VK_RESULT", "QueueAddMemReference", - [Param("VK_QUEUE", "queue"), - Param("VK_GPU_MEMORY", "mem")]), + Proto("VkResult", "QueueAddMemReference", + [Param("VkQueue", "queue"), + Param("VkGpuMemory", "mem")]), - Proto("VK_RESULT", "QueueRemoveMemReference", - [Param("VK_QUEUE", "queue"), - Param("VK_GPU_MEMORY", "mem")]), + Proto("VkResult", "QueueRemoveMemReference", + [Param("VkQueue", "queue"), + Param("VkGpuMemory", "mem")]), - Proto("VK_RESULT", "QueueWaitIdle", - [Param("VK_QUEUE", "queue")]), + Proto("VkResult", "QueueWaitIdle", + [Param("VkQueue", "queue")]), - Proto("VK_RESULT", "DeviceWaitIdle", - [Param("VK_DEVICE", "device")]), + Proto("VkResult", "DeviceWaitIdle", + [Param("VkDevice", "device")]), - Proto("VK_RESULT", "AllocMemory", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "AllocMemory", + [Param("VkDevice", "device"), Param("const VkMemoryAllocInfo*", "pAllocInfo"), - Param("VK_GPU_MEMORY*", "pMem")]), + Param("VkGpuMemory*", "pMem")]), - Proto("VK_RESULT", "FreeMemory", - [Param("VK_GPU_MEMORY", "mem")]), + Proto("VkResult", "FreeMemory", + [Param("VkGpuMemory", "mem")]), - Proto("VK_RESULT", "SetMemoryPriority", - [Param("VK_GPU_MEMORY", "mem"), - Param("VK_MEMORY_PRIORITY", "priority")]), + Proto("VkResult", "SetMemoryPriority", + [Param("VkGpuMemory", "mem"), + Param("VkMemoryPriority", "priority")]), - Proto("VK_RESULT", "MapMemory", - [Param("VK_GPU_MEMORY", "mem"), - Param("VK_FLAGS", "flags"), + Proto("VkResult", "MapMemory", + [Param("VkGpuMemory", "mem"), + Param("VkFlags", "flags"), Param("void**", "ppData")]), - Proto("VK_RESULT", "UnmapMemory", - [Param("VK_GPU_MEMORY", "mem")]), + Proto("VkResult", "UnmapMemory", + [Param("VkGpuMemory", "mem")]), - Proto("VK_RESULT", "PinSystemMemory", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "PinSystemMemory", + [Param("VkDevice", "device"), Param("const void*", "pSysMem"), Param("size_t", "memSize"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "GetMultiGpuCompatibility", - [Param("VK_PHYSICAL_GPU", "gpu0"), - Param("VK_PHYSICAL_GPU", "gpu1"), - Param("VK_GPU_COMPATIBILITY_INFO*", "pInfo")]), - - Proto("VK_RESULT", "OpenSharedMemory", - [Param("VK_DEVICE", "device"), - Param("const VK_MEMORY_OPEN_INFO*", "pOpenInfo"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "OpenSharedSemaphore", - [Param("VK_DEVICE", "device"), - Param("const VK_SEMAPHORE_OPEN_INFO*", "pOpenInfo"), - Param("VK_SEMAPHORE*", "pSemaphore")]), - - Proto("VK_RESULT", "OpenPeerMemory", - [Param("VK_DEVICE", "device"), - Param("const VK_PEER_MEMORY_OPEN_INFO*", "pOpenInfo"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "OpenPeerImage", - [Param("VK_DEVICE", "device"), - Param("const VK_PEER_IMAGE_OPEN_INFO*", "pOpenInfo"), - Param("VK_IMAGE*", "pImage"), - Param("VK_GPU_MEMORY*", "pMem")]), - - Proto("VK_RESULT", "DestroyObject", - [Param("VK_OBJECT", "object")]), - - Proto("VK_RESULT", "GetObjectInfo", - [Param("VK_BASE_OBJECT", "object"), - Param("VK_OBJECT_INFO_TYPE", "infoType"), + Param("VkGpuMemory*", "pMem")]), + + Proto("VkResult", "GetMultiGpuCompatibility", + [Param("VkPhysicalGpu", "gpu0"), + Param("VkPhysicalGpu", "gpu1"), + Param("VkGpuCompatibilityInfo*", "pInfo")]), + + Proto("VkResult", "OpenSharedMemory", + [Param("VkDevice", "device"), + Param("const VkMemoryOpenInfo*", "pOpenInfo"), + Param("VkGpuMemory*", "pMem")]), + + Proto("VkResult", "OpenSharedSemaphore", + [Param("VkDevice", "device"), + Param("const VkSemaphoreOpenInfo*", "pOpenInfo"), + Param("VkSemaphore*", "pSemaphore")]), + + Proto("VkResult", "OpenPeerMemory", + [Param("VkDevice", "device"), + Param("const VkPeerMemoryOpenInfo*", "pOpenInfo"), + Param("VkGpuMemory*", "pMem")]), + + Proto("VkResult", "OpenPeerImage", + [Param("VkDevice", "device"), + Param("const VkPeerImageOpenInfo*", "pOpenInfo"), + Param("VkImage*", "pImage"), + Param("VkGpuMemory*", "pMem")]), + + Proto("VkResult", "DestroyObject", + [Param("VkObject", "object")]), + + Proto("VkResult", "GetObjectInfo", + [Param("VkBaseObject", "object"), + Param("VkObjectInfoType", "infoType"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), - Proto("VK_RESULT", "BindObjectMemory", - [Param("VK_OBJECT", "object"), + Proto("VkResult", "BindObjectMemory", + [Param("VkObject", "object"), Param("uint32_t", "allocationIdx"), - Param("VK_GPU_MEMORY", "mem"), - Param("VK_GPU_SIZE", "offset")]), + Param("VkGpuMemory", "mem"), + Param("VkGpuSize", "offset")]), - Proto("VK_RESULT", "BindObjectMemoryRange", - [Param("VK_OBJECT", "object"), + Proto("VkResult", "BindObjectMemoryRange", + [Param("VkObject", "object"), Param("uint32_t", "allocationIdx"), - Param("VK_GPU_SIZE", "rangeOffset"), - Param("VK_GPU_SIZE", "rangeSize"), - Param("VK_GPU_MEMORY", "mem"), - Param("VK_GPU_SIZE", "memOffset")]), + Param("VkGpuSize", "rangeOffset"), + Param("VkGpuSize", "rangeSize"), + Param("VkGpuMemory", "mem"), + Param("VkGpuSize", "memOffset")]), - Proto("VK_RESULT", "BindImageMemoryRange", - [Param("VK_IMAGE", "image"), + Proto("VkResult", "BindImageMemoryRange", + [Param("VkImage", "image"), Param("uint32_t", "allocationIdx"), - Param("const VK_IMAGE_MEMORY_BIND_INFO*", "bindInfo"), - Param("VK_GPU_MEMORY", "mem"), - Param("VK_GPU_SIZE", "memOffset")]), + Param("const VkImageMemoryBindInfo*", "bindInfo"), + Param("VkGpuMemory", "mem"), + Param("VkGpuSize", "memOffset")]), - Proto("VK_RESULT", "CreateFence", - [Param("VK_DEVICE", "device"), - Param("const VK_FENCE_CREATE_INFO*", "pCreateInfo"), - Param("VK_FENCE*", "pFence")]), + Proto("VkResult", "CreateFence", + [Param("VkDevice", "device"), + Param("const VkFenceCreateInfo*", "pCreateInfo"), + Param("VkFence*", "pFence")]), - Proto("VK_RESULT", "ResetFences", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "ResetFences", + [Param("VkDevice", "device"), Param("uint32_t", "fenceCount"), - Param("VK_FENCE*", "pFences")]), + Param("VkFence*", "pFences")]), - Proto("VK_RESULT", "GetFenceStatus", - [Param("VK_FENCE", "fence")]), + Proto("VkResult", "GetFenceStatus", + [Param("VkFence", "fence")]), - Proto("VK_RESULT", "WaitForFences", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "WaitForFences", + [Param("VkDevice", "device"), Param("uint32_t", "fenceCount"), - Param("const VK_FENCE*", "pFences"), + Param("const VkFence*", "pFences"), Param("bool32_t", "waitAll"), Param("uint64_t", "timeout")]), - Proto("VK_RESULT", "CreateSemaphore", - [Param("VK_DEVICE", "device"), - Param("const VK_SEMAPHORE_CREATE_INFO*", "pCreateInfo"), - Param("VK_SEMAPHORE*", "pSemaphore")]), + Proto("VkResult", "CreateSemaphore", + [Param("VkDevice", "device"), + Param("const VkSemaphoreCreateInfo*", "pCreateInfo"), + Param("VkSemaphore*", "pSemaphore")]), - Proto("VK_RESULT", "QueueSignalSemaphore", - [Param("VK_QUEUE", "queue"), - Param("VK_SEMAPHORE", "semaphore")]), + Proto("VkResult", "QueueSignalSemaphore", + [Param("VkQueue", "queue"), + Param("VkSemaphore", "semaphore")]), - Proto("VK_RESULT", "QueueWaitSemaphore", - [Param("VK_QUEUE", "queue"), - Param("VK_SEMAPHORE", "semaphore")]), + Proto("VkResult", "QueueWaitSemaphore", + [Param("VkQueue", "queue"), + Param("VkSemaphore", "semaphore")]), - Proto("VK_RESULT", "CreateEvent", - [Param("VK_DEVICE", "device"), - Param("const VK_EVENT_CREATE_INFO*", "pCreateInfo"), - Param("VK_EVENT*", "pEvent")]), + Proto("VkResult", "CreateEvent", + [Param("VkDevice", "device"), + Param("const VkEventCreateInfo*", "pCreateInfo"), + Param("VkEvent*", "pEvent")]), - Proto("VK_RESULT", "GetEventStatus", - [Param("VK_EVENT", "event")]), + Proto("VkResult", "GetEventStatus", + [Param("VkEvent", "event")]), - Proto("VK_RESULT", "SetEvent", - [Param("VK_EVENT", "event")]), + Proto("VkResult", "SetEvent", + [Param("VkEvent", "event")]), - Proto("VK_RESULT", "ResetEvent", - [Param("VK_EVENT", "event")]), + Proto("VkResult", "ResetEvent", + [Param("VkEvent", "event")]), - Proto("VK_RESULT", "CreateQueryPool", - [Param("VK_DEVICE", "device"), - Param("const VK_QUERY_POOL_CREATE_INFO*", "pCreateInfo"), - Param("VK_QUERY_POOL*", "pQueryPool")]), + Proto("VkResult", "CreateQueryPool", + [Param("VkDevice", "device"), + Param("const VkQueryPoolCreateInfo*", "pCreateInfo"), + Param("VkQueryPool*", "pQueryPool")]), - Proto("VK_RESULT", "GetQueryPoolResults", - [Param("VK_QUERY_POOL", "queryPool"), + Proto("VkResult", "GetQueryPoolResults", + [Param("VkQueryPool", "queryPool"), Param("uint32_t", "startQuery"), Param("uint32_t", "queryCount"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), - Proto("VK_RESULT", "GetFormatInfo", - [Param("VK_DEVICE", "device"), - Param("VK_FORMAT", "format"), - Param("VK_FORMAT_INFO_TYPE", "infoType"), + Proto("VkResult", "GetFormatInfo", + [Param("VkDevice", "device"), + Param("VkFormat", "format"), + Param("VkFormatInfoType", "infoType"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), - Proto("VK_RESULT", "CreateBuffer", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "CreateBuffer", + [Param("VkDevice", "device"), Param("const VkBufferCreateInfo*", "pCreateInfo"), - Param("VK_BUFFER*", "pBuffer")]), + Param("VkBuffer*", "pBuffer")]), - Proto("VK_RESULT", "CreateBufferView", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "CreateBufferView", + [Param("VkDevice", "device"), Param("const VkBufferViewCreateInfo*", "pCreateInfo"), - Param("VK_BUFFER_VIEW*", "pView")]), + Param("VkBufferView*", "pView")]), - Proto("VK_RESULT", "CreateImage", - [Param("VK_DEVICE", "device"), - Param("const VK_IMAGE_CREATE_INFO*", "pCreateInfo"), - Param("VK_IMAGE*", "pImage")]), + Proto("VkResult", "CreateImage", + [Param("VkDevice", "device"), + Param("const VkImageCreateInfo*", "pCreateInfo"), + Param("VkImage*", "pImage")]), - Proto("VK_RESULT", "GetImageSubresourceInfo", - [Param("VK_IMAGE", "image"), - Param("const VK_IMAGE_SUBRESOURCE*", "pSubresource"), - Param("VK_SUBRESOURCE_INFO_TYPE", "infoType"), + Proto("VkResult", "GetImageSubresourceInfo", + [Param("VkImage", "image"), + Param("const VkImageSubresource*", "pSubresource"), + Param("VkSubresourceInfoType", "infoType"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), - Proto("VK_RESULT", "CreateImageView", - [Param("VK_DEVICE", "device"), - Param("const VK_IMAGE_VIEW_CREATE_INFO*", "pCreateInfo"), - Param("VK_IMAGE_VIEW*", "pView")]), - - Proto("VK_RESULT", "CreateColorAttachmentView", - [Param("VK_DEVICE", "device"), - Param("const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO*", "pCreateInfo"), - Param("VK_COLOR_ATTACHMENT_VIEW*", "pView")]), - - Proto("VK_RESULT", "CreateDepthStencilView", - [Param("VK_DEVICE", "device"), - Param("const VK_DEPTH_STENCIL_VIEW_CREATE_INFO*", "pCreateInfo"), - Param("VK_DEPTH_STENCIL_VIEW*", "pView")]), - - Proto("VK_RESULT", "CreateShader", - [Param("VK_DEVICE", "device"), - Param("const VK_SHADER_CREATE_INFO*", "pCreateInfo"), - Param("VK_SHADER*", "pShader")]), - - Proto("VK_RESULT", "CreateGraphicsPipeline", - [Param("VK_DEVICE", "device"), - Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "CreateGraphicsPipelineDerivative", - [Param("VK_DEVICE", "device"), - Param("const VK_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"), - Param("VK_PIPELINE", "basePipeline"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "CreateComputePipeline", - [Param("VK_DEVICE", "device"), - Param("const VK_COMPUTE_PIPELINE_CREATE_INFO*", "pCreateInfo"), - Param("VK_PIPELINE*", "pPipeline")]), - - Proto("VK_RESULT", "StorePipeline", - [Param("VK_PIPELINE", "pipeline"), + Proto("VkResult", "CreateImageView", + [Param("VkDevice", "device"), + Param("const VkImageViewCreateInfo*", "pCreateInfo"), + Param("VkImageView*", "pView")]), + + Proto("VkResult", "CreateColorAttachmentView", + [Param("VkDevice", "device"), + Param("const VkColorAttachmentViewCreateInfo*", "pCreateInfo"), + Param("VkColorAttachmentView*", "pView")]), + + Proto("VkResult", "CreateDepthStencilView", + [Param("VkDevice", "device"), + Param("const VkDepthStencilViewCreateInfo*", "pCreateInfo"), + Param("VkDepthStencilView*", "pView")]), + + Proto("VkResult", "CreateShader", + [Param("VkDevice", "device"), + Param("const VkShaderCreateInfo*", "pCreateInfo"), + Param("VkShader*", "pShader")]), + + Proto("VkResult", "CreateGraphicsPipeline", + [Param("VkDevice", "device"), + Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfo"), + Param("VkPipeline*", "pPipeline")]), + + Proto("VkResult", "CreateGraphicsPipelineDerivative", + [Param("VkDevice", "device"), + Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfo"), + Param("VkPipeline", "basePipeline"), + Param("VkPipeline*", "pPipeline")]), + + Proto("VkResult", "CreateComputePipeline", + [Param("VkDevice", "device"), + Param("const VkComputePipelineCreateInfo*", "pCreateInfo"), + Param("VkPipeline*", "pPipeline")]), + + Proto("VkResult", "StorePipeline", + [Param("VkPipeline", "pipeline"), Param("size_t*", "pDataSize"), Param("void*", "pData")]), - Proto("VK_RESULT", "LoadPipeline", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "LoadPipeline", + [Param("VkDevice", "device"), Param("size_t", "dataSize"), Param("const void*", "pData"), - Param("VK_PIPELINE*", "pPipeline")]), + Param("VkPipeline*", "pPipeline")]), - Proto("VK_RESULT", "LoadPipelineDerivative", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "LoadPipelineDerivative", + [Param("VkDevice", "device"), Param("size_t", "dataSize"), Param("const void*", "pData"), - Param("VK_PIPELINE", "basePipeline"), - Param("VK_PIPELINE*", "pPipeline")]), + Param("VkPipeline", "basePipeline"), + Param("VkPipeline*", "pPipeline")]), - Proto("VK_RESULT", "CreateSampler", - [Param("VK_DEVICE", "device"), - Param("const VK_SAMPLER_CREATE_INFO*", "pCreateInfo"), - Param("VK_SAMPLER*", "pSampler")]), + Proto("VkResult", "CreateSampler", + [Param("VkDevice", "device"), + Param("const VkSamplerCreateInfo*", "pCreateInfo"), + Param("VkSampler*", "pSampler")]), - Proto("VK_RESULT", "CreateDescriptorSetLayout", - [Param("VK_DEVICE", "device"), - Param("const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*", "pCreateInfo"), - Param("VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayout")]), + Proto("VkResult", "CreateDescriptorSetLayout", + [Param("VkDevice", "device"), + Param("const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo"), + Param("VkDescriptorSetLayout*", "pSetLayout")]), - Proto("VK_RESULT", "CreateDescriptorSetLayoutChain", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "CreateDescriptorSetLayoutChain", + [Param("VkDevice", "device"), Param("uint32_t", "setLayoutArrayCount"), - Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayoutArray"), - Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN*", "pLayoutChain")]), + Param("const VkDescriptorSetLayout*", "pSetLayoutArray"), + Param("VkDescriptorSetLayoutChain*", "pLayoutChain")]), - Proto("VK_RESULT", "BeginDescriptorPoolUpdate", - [Param("VK_DEVICE", "device"), - Param("VK_DESCRIPTOR_UPDATE_MODE", "updateMode")]), + Proto("VkResult", "BeginDescriptorPoolUpdate", + [Param("VkDevice", "device"), + Param("VkDescriptorUpdateMode", "updateMode")]), - Proto("VK_RESULT", "EndDescriptorPoolUpdate", - [Param("VK_DEVICE", "device"), - Param("VK_CMD_BUFFER", "cmd")]), + Proto("VkResult", "EndDescriptorPoolUpdate", + [Param("VkDevice", "device"), + Param("VkCmdBuffer", "cmd")]), - Proto("VK_RESULT", "CreateDescriptorPool", - [Param("VK_DEVICE", "device"), - Param("VK_DESCRIPTOR_POOL_USAGE", "poolUsage"), + Proto("VkResult", "CreateDescriptorPool", + [Param("VkDevice", "device"), + Param("VkDescriptorPoolUsage", "poolUsage"), Param("uint32_t", "maxSets"), - Param("const VK_DESCRIPTOR_POOL_CREATE_INFO*", "pCreateInfo"), - Param("VK_DESCRIPTOR_POOL*", "pDescriptorPool")]), + Param("const VkDescriptorPoolCreateInfo*", "pCreateInfo"), + Param("VkDescriptorPool*", "pDescriptorPool")]), - Proto("VK_RESULT", "ResetDescriptorPool", - [Param("VK_DESCRIPTOR_POOL", "descriptorPool")]), + Proto("VkResult", "ResetDescriptorPool", + [Param("VkDescriptorPool", "descriptorPool")]), - Proto("VK_RESULT", "AllocDescriptorSets", - [Param("VK_DESCRIPTOR_POOL", "descriptorPool"), - Param("VK_DESCRIPTOR_SET_USAGE", "setUsage"), + Proto("VkResult", "AllocDescriptorSets", + [Param("VkDescriptorPool", "descriptorPool"), + Param("VkDescriptorSetUsage", "setUsage"), Param("uint32_t", "count"), - Param("const VK_DESCRIPTOR_SET_LAYOUT*", "pSetLayouts"), - Param("VK_DESCRIPTOR_SET*", "pDescriptorSets"), + Param("const VkDescriptorSetLayout*", "pSetLayouts"), + Param("VkDescriptorSet*", "pDescriptorSets"), Param("uint32_t*", "pCount")]), Proto("void", "ClearDescriptorSets", - [Param("VK_DESCRIPTOR_POOL", "descriptorPool"), + [Param("VkDescriptorPool", "descriptorPool"), Param("uint32_t", "count"), - Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets")]), + Param("const VkDescriptorSet*", "pDescriptorSets")]), Proto("void", "UpdateDescriptors", - [Param("VK_DESCRIPTOR_SET", "descriptorSet"), + [Param("VkDescriptorSet", "descriptorSet"), Param("uint32_t", "updateCount"), Param("const void**", "ppUpdateArray")]), - Proto("VK_RESULT", "CreateDynamicViewportState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_VP_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_VP_STATE_OBJECT*", "pState")]), + Proto("VkResult", "CreateDynamicViewportState", + [Param("VkDevice", "device"), + Param("const VkDynamicVpStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicVpStateObject*", "pState")]), - Proto("VK_RESULT", "CreateDynamicRasterState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_RS_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_RS_STATE_OBJECT*", "pState")]), + Proto("VkResult", "CreateDynamicRasterState", + [Param("VkDevice", "device"), + Param("const VkDynamicRsStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicRsStateObject*", "pState")]), - Proto("VK_RESULT", "CreateDynamicColorBlendState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_CB_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_CB_STATE_OBJECT*", "pState")]), + Proto("VkResult", "CreateDynamicColorBlendState", + [Param("VkDevice", "device"), + Param("const VkDynamicCbStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicCbStateObject*", "pState")]), - Proto("VK_RESULT", "CreateDynamicDepthStencilState", - [Param("VK_DEVICE", "device"), - Param("const VK_DYNAMIC_DS_STATE_CREATE_INFO*", "pCreateInfo"), - Param("VK_DYNAMIC_DS_STATE_OBJECT*", "pState")]), + Proto("VkResult", "CreateDynamicDepthStencilState", + [Param("VkDevice", "device"), + Param("const VkDynamicDsStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicDsStateObject*", "pState")]), - Proto("VK_RESULT", "CreateCommandBuffer", - [Param("VK_DEVICE", "device"), - Param("const VK_CMD_BUFFER_CREATE_INFO*", "pCreateInfo"), - Param("VK_CMD_BUFFER*", "pCmdBuffer")]), + Proto("VkResult", "CreateCommandBuffer", + [Param("VkDevice", "device"), + Param("const VkCmdBufferCreateInfo*", "pCreateInfo"), + Param("VkCmdBuffer*", "pCmdBuffer")]), - Proto("VK_RESULT", "BeginCommandBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_CMD_BUFFER_BEGIN_INFO*", "pBeginInfo")]), + Proto("VkResult", "BeginCommandBuffer", + [Param("VkCmdBuffer", "cmdBuffer"), + Param("const VkCmdBufferBeginInfo*", "pBeginInfo")]), - Proto("VK_RESULT", "EndCommandBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer")]), + Proto("VkResult", "EndCommandBuffer", + [Param("VkCmdBuffer", "cmdBuffer")]), - Proto("VK_RESULT", "ResetCommandBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer")]), + Proto("VkResult", "ResetCommandBuffer", + [Param("VkCmdBuffer", "cmdBuffer")]), Proto("void", "CmdBindPipeline", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), - Param("VK_PIPELINE", "pipeline")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkPipelineBindPoint", "pipelineBindPoint"), + Param("VkPipeline", "pipeline")]), Proto("void", "CmdBindDynamicStateObject", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_STATE_BIND_POINT", "stateBindPoint"), - Param("VK_DYNAMIC_STATE_OBJECT", "state")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkStateBindPoint", "stateBindPoint"), + Param("VkDynamicStateObject", "state")]), Proto("void", "CmdBindDescriptorSets", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), - Param("VK_DESCRIPTOR_SET_LAYOUT_CHAIN", "layoutChain"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkPipelineBindPoint", "pipelineBindPoint"), + Param("VkDescriptorSetLayoutChain", "layoutChain"), Param("uint32_t", "layoutChainSlot"), Param("uint32_t", "count"), - Param("const VK_DESCRIPTOR_SET*", "pDescriptorSets"), + Param("const VkDescriptorSet*", "pDescriptorSets"), Param("const uint32_t*", "pUserData")]), Proto("void", "CmdBindVertexBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "buffer"), + Param("VkGpuSize", "offset"), Param("uint32_t", "binding")]), Proto("void", "CmdBindIndexBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), - Param("VK_INDEX_TYPE", "indexType")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "buffer"), + Param("VkGpuSize", "offset"), + Param("VkIndexType", "indexType")]), Proto("void", "CmdDraw", - [Param("VK_CMD_BUFFER", "cmdBuffer"), + [Param("VkCmdBuffer", "cmdBuffer"), Param("uint32_t", "firstVertex"), Param("uint32_t", "vertexCount"), Param("uint32_t", "firstInstance"), Param("uint32_t", "instanceCount")]), Proto("void", "CmdDrawIndexed", - [Param("VK_CMD_BUFFER", "cmdBuffer"), + [Param("VkCmdBuffer", "cmdBuffer"), Param("uint32_t", "firstIndex"), Param("uint32_t", "indexCount"), Param("int32_t", "vertexOffset"), @@ -644,241 +644,241 @@ core = Extension( Param("uint32_t", "instanceCount")]), Proto("void", "CmdDrawIndirect", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "buffer"), + Param("VkGpuSize", "offset"), Param("uint32_t", "count"), Param("uint32_t", "stride")]), Proto("void", "CmdDrawIndexedIndirect", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "buffer"), + Param("VkGpuSize", "offset"), Param("uint32_t", "count"), Param("uint32_t", "stride")]), Proto("void", "CmdDispatch", - [Param("VK_CMD_BUFFER", "cmdBuffer"), + [Param("VkCmdBuffer", "cmdBuffer"), Param("uint32_t", "x"), Param("uint32_t", "y"), Param("uint32_t", "z")]), Proto("void", "CmdDispatchIndirect", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "buffer"), - Param("VK_GPU_SIZE", "offset")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "buffer"), + Param("VkGpuSize", "offset")]), Proto("void", "CmdCopyBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "srcBuffer"), - Param("VK_BUFFER", "destBuffer"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "srcBuffer"), + Param("VkBuffer", "destBuffer"), Param("uint32_t", "regionCount"), - Param("const VK_BUFFER_COPY*", "pRegions")]), + Param("const VkBufferCopy*", "pRegions")]), Proto("void", "CmdCopyImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkImage", "srcImage"), + Param("VkImageLayout", "srcImageLayout"), + Param("VkImage", "destImage"), + Param("VkImageLayout", "destImageLayout"), Param("uint32_t", "regionCount"), - Param("const VK_IMAGE_COPY*", "pRegions")]), + Param("const VkImageCopy*", "pRegions")]), Proto("void", "CmdBlitImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkImage", "srcImage"), + Param("VkImageLayout", "srcImageLayout"), + Param("VkImage", "destImage"), + Param("VkImageLayout", "destImageLayout"), Param("uint32_t", "regionCount"), - Param("const VK_IMAGE_BLIT*", "pRegions")]), + Param("const VkImageBlit*", "pRegions")]), Proto("void", "CmdCopyBufferToImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "srcBuffer"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "srcBuffer"), + Param("VkImage", "destImage"), + Param("VkImageLayout", "destImageLayout"), Param("uint32_t", "regionCount"), - Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]), + Param("const VkBufferImageCopy*", "pRegions")]), Proto("void", "CmdCopyImageToBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_BUFFER", "destBuffer"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkImage", "srcImage"), + Param("VkImageLayout", "srcImageLayout"), + Param("VkBuffer", "destBuffer"), Param("uint32_t", "regionCount"), - Param("const VK_BUFFER_IMAGE_COPY*", "pRegions")]), + Param("const VkBufferImageCopy*", "pRegions")]), Proto("void", "CmdCloneImageData", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkImage", "srcImage"), + Param("VkImageLayout", "srcImageLayout"), + Param("VkImage", "destImage"), + Param("VkImageLayout", "destImageLayout")]), Proto("void", "CmdUpdateBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset"), - Param("VK_GPU_SIZE", "dataSize"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "destBuffer"), + Param("VkGpuSize", "destOffset"), + Param("VkGpuSize", "dataSize"), Param("const uint32_t*", "pData")]), Proto("void", "CmdFillBuffer", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset"), - Param("VK_GPU_SIZE", "fillSize"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkBuffer", "destBuffer"), + Param("VkGpuSize", "destOffset"), + Param("VkGpuSize", "fillSize"), Param("uint32_t", "data")]), Proto("void", "CmdClearColorImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "image"), - Param("VK_IMAGE_LAYOUT", "imageLayout"), - Param("VK_CLEAR_COLOR", "color"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkImage", "image"), + Param("VkImageLayout", "imageLayout"), + Param("VkClearColor", "color"), Param("uint32_t", "rangeCount"), - Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]), + Param("const VkImageSubresourceRange*", "pRanges")]), Proto("void", "CmdClearDepthStencil", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "image"), - Param("VK_IMAGE_LAYOUT", "imageLayout"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkImage", "image"), + Param("VkImageLayout", "imageLayout"), Param("float", "depth"), Param("uint32_t", "stencil"), Param("uint32_t", "rangeCount"), - Param("const VK_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]), + Param("const VkImageSubresourceRange*", "pRanges")]), Proto("void", "CmdResolveImage", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_IMAGE", "srcImage"), - Param("VK_IMAGE_LAYOUT", "srcImageLayout"), - Param("VK_IMAGE", "destImage"), - Param("VK_IMAGE_LAYOUT", "destImageLayout"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkImage", "srcImage"), + Param("VkImageLayout", "srcImageLayout"), + Param("VkImage", "destImage"), + Param("VkImageLayout", "destImageLayout"), Param("uint32_t", "rectCount"), - Param("const VK_IMAGE_RESOLVE*", "pRects")]), + Param("const VkImageResolve*", "pRects")]), Proto("void", "CmdSetEvent", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_EVENT", "event"), - Param("VK_PIPE_EVENT", "pipeEvent")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkEvent", "event"), + Param("VkPipeEvent", "pipeEvent")]), Proto("void", "CmdResetEvent", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_EVENT", "event"), - Param("VK_PIPE_EVENT", "pipeEvent")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkEvent", "event"), + Param("VkPipeEvent", "pipeEvent")]), Proto("void", "CmdWaitEvents", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_EVENT_WAIT_INFO*", "pWaitInfo")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("const VkEventWaitInfo*", "pWaitInfo")]), Proto("void", "CmdPipelineBarrier", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_PIPELINE_BARRIER*", "pBarrier")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("const VkPipelineBarrier*", "pBarrier")]), Proto("void", "CmdBeginQuery", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_QUERY_POOL", "queryPool"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkQueryPool", "queryPool"), Param("uint32_t", "slot"), - Param("VK_FLAGS", "flags")]), + Param("VkFlags", "flags")]), Proto("void", "CmdEndQuery", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_QUERY_POOL", "queryPool"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkQueryPool", "queryPool"), Param("uint32_t", "slot")]), Proto("void", "CmdResetQueryPool", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_QUERY_POOL", "queryPool"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkQueryPool", "queryPool"), Param("uint32_t", "startQuery"), Param("uint32_t", "queryCount")]), Proto("void", "CmdWriteTimestamp", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_TIMESTAMP_TYPE", "timestampType"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkTimestampType", "timestampType"), + Param("VkBuffer", "destBuffer"), + Param("VkGpuSize", "destOffset")]), Proto("void", "CmdInitAtomicCounters", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkPipelineBindPoint", "pipelineBindPoint"), Param("uint32_t", "startCounter"), Param("uint32_t", "counterCount"), Param("const uint32_t*", "pData")]), Proto("void", "CmdLoadAtomicCounters", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkPipelineBindPoint", "pipelineBindPoint"), Param("uint32_t", "startCounter"), Param("uint32_t", "counterCount"), - Param("VK_BUFFER", "srcBuffer"), - Param("VK_GPU_SIZE", "srcOffset")]), + Param("VkBuffer", "srcBuffer"), + Param("VkGpuSize", "srcOffset")]), Proto("void", "CmdSaveAtomicCounters", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_PIPELINE_BIND_POINT", "pipelineBindPoint"), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkPipelineBindPoint", "pipelineBindPoint"), Param("uint32_t", "startCounter"), Param("uint32_t", "counterCount"), - Param("VK_BUFFER", "destBuffer"), - Param("VK_GPU_SIZE", "destOffset")]), + Param("VkBuffer", "destBuffer"), + Param("VkGpuSize", "destOffset")]), - Proto("VK_RESULT", "CreateFramebuffer", - [Param("VK_DEVICE", "device"), - Param("const VK_FRAMEBUFFER_CREATE_INFO*", "pCreateInfo"), - Param("VK_FRAMEBUFFER*", "pFramebuffer")]), + Proto("VkResult", "CreateFramebuffer", + [Param("VkDevice", "device"), + Param("const VkFramebufferCreateInfo*", "pCreateInfo"), + Param("VkFramebuffer*", "pFramebuffer")]), - Proto("VK_RESULT", "CreateRenderPass", - [Param("VK_DEVICE", "device"), - Param("const VK_RENDER_PASS_CREATE_INFO*", "pCreateInfo"), - Param("VK_RENDER_PASS*", "pRenderPass")]), + Proto("VkResult", "CreateRenderPass", + [Param("VkDevice", "device"), + Param("const VkRenderPassCreateInfo*", "pCreateInfo"), + Param("VkRenderPass*", "pRenderPass")]), Proto("void", "CmdBeginRenderPass", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("const VK_RENDER_PASS_BEGIN*", "pRenderPassBegin")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("const VkRenderPassBegin*", "pRenderPassBegin")]), Proto("void", "CmdEndRenderPass", - [Param("VK_CMD_BUFFER", "cmdBuffer"), - Param("VK_RENDER_PASS", "renderPass")]), + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkRenderPass", "renderPass")]), - Proto("VK_RESULT", "DbgSetValidationLevel", - [Param("VK_DEVICE", "device"), - Param("VK_VALIDATION_LEVEL", "validationLevel")]), + Proto("VkResult", "DbgSetValidationLevel", + [Param("VkDevice", "device"), + Param("VkValidationLevel", "validationLevel")]), - Proto("VK_RESULT", "DbgRegisterMsgCallback", - [Param("VK_INSTANCE", "instance"), + Proto("VkResult", "DbgRegisterMsgCallback", + [Param("VkInstance", "instance"), Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback"), Param("void*", "pUserData")]), - Proto("VK_RESULT", "DbgUnregisterMsgCallback", - [Param("VK_INSTANCE", "instance"), + Proto("VkResult", "DbgUnregisterMsgCallback", + [Param("VkInstance", "instance"), Param("VK_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback")]), - Proto("VK_RESULT", "DbgSetMessageFilter", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "DbgSetMessageFilter", + [Param("VkDevice", "device"), Param("int32_t", "msgCode"), Param("VK_DBG_MSG_FILTER", "filter")]), - Proto("VK_RESULT", "DbgSetObjectTag", - [Param("VK_BASE_OBJECT", "object"), + Proto("VkResult", "DbgSetObjectTag", + [Param("VkBaseObject", "object"), Param("size_t", "tagSize"), Param("const void*", "pTag")]), - Proto("VK_RESULT", "DbgSetGlobalOption", - [Param("VK_INSTANCE", "instance"), + Proto("VkResult", "DbgSetGlobalOption", + [Param("VkInstance", "instance"), Param("VK_DBG_GLOBAL_OPTION", "dbgOption"), Param("size_t", "dataSize"), Param("const void*", "pData")]), - Proto("VK_RESULT", "DbgSetDeviceOption", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "DbgSetDeviceOption", + [Param("VkDevice", "device"), Param("VK_DBG_DEVICE_OPTION", "dbgOption"), Param("size_t", "dataSize"), Param("const void*", "pData")]), Proto("void", "CmdDbgMarkerBegin", - [Param("VK_CMD_BUFFER", "cmdBuffer"), + [Param("VkCmdBuffer", "cmdBuffer"), Param("const char*", "pMarker")]), Proto("void", "CmdDbgMarkerEnd", - [Param("VK_CMD_BUFFER", "cmdBuffer")]), + [Param("VkCmdBuffer", "cmdBuffer")]), ], ) @@ -887,78 +887,78 @@ wsi_x11 = Extension( headers=["vkWsiX11Ext.h"], objects=[], protos=[ - Proto("VK_RESULT", "WsiX11AssociateConnection", - [Param("VK_PHYSICAL_GPU", "gpu"), + Proto("VkResult", "WsiX11AssociateConnection", + [Param("VkPhysicalGpu", "gpu"), Param("const VK_WSI_X11_CONNECTION_INFO*", "pConnectionInfo")]), - Proto("VK_RESULT", "WsiX11GetMSC", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "WsiX11GetMSC", + [Param("VkDevice", "device"), Param("xcb_window_t", "window"), Param("xcb_randr_crtc_t", "crtc"), Param("uint64_t*", "pMsc")]), - Proto("VK_RESULT", "WsiX11CreatePresentableImage", - [Param("VK_DEVICE", "device"), + Proto("VkResult", "WsiX11CreatePresentableImage", + [Param("VkDevice", "device"), Param("const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO*", "pCreateInfo"), - Param("VK_IMAGE*", "pImage"), - Param("VK_GPU_MEMORY*", "pMem")]), + Param("VkImage*", "pImage"), + Param("VkGpuMemory*", "pMem")]), - Proto("VK_RESULT", "WsiX11QueuePresent", - [Param("VK_QUEUE", "queue"), + Proto("VkResult", "WsiX11QueuePresent", + [Param("VkQueue", "queue"), Param("const VK_WSI_X11_PRESENT_INFO*", "pPresentInfo"), - Param("VK_FENCE", "fence")]), + Param("VkFence", "fence")]), ], ) extensions = [core, wsi_x11] object_root_list = [ - "VK_INSTANCE", - "VK_PHYSICAL_GPU", - "VK_BASE_OBJECT" + "VkInstance", + "VkPhysicalGpu", + "VkBaseObject" ] object_base_list = [ - "VK_DEVICE", - "VK_QUEUE", - "VK_GPU_MEMORY", - "VK_OBJECT" + "VkDevice", + "VkQueue", + "VkGpuMemory", + "VkObject" ] object_list = [ - "VK_BUFFER", - "VK_BUFFER_VIEW", - "VK_IMAGE", - "VK_IMAGE_VIEW", - "VK_COLOR_ATTACHMENT_VIEW", - "VK_DEPTH_STENCIL_VIEW", - "VK_SHADER", - "VK_PIPELINE", - "VK_SAMPLER", - "VK_DESCRIPTOR_SET", - "VK_DESCRIPTOR_SET_LAYOUT", - "VK_DESCRIPTOR_SET_LAYOUT_CHAIN", - "VK_DESCRIPTOR_POOL", - "VK_DYNAMIC_STATE_OBJECT", - "VK_CMD_BUFFER", - "VK_FENCE", - "VK_SEMAPHORE", - "VK_EVENT", - "VK_QUERY_POOL", - "VK_FRAMEBUFFER", - "VK_RENDER_PASS" + "VkBuffer", + "VkBufferView", + "VkImage", + "VkImageView", + "VkColorAttachmentView", + "VkDepthStencilView", + "VkShader", + "VkPipeline", + "VkSampler", + "VkDescriptorSet", + "VkDescriptorSetLayout", + "VkDescriptorSetLayoutChain", + "VkDescriptorPool", + "VkDynamicStateObject", + "VkCmdBuffer", + "VkFence", + "VkSemaphore", + "VkEvent", + "VkQueryPool", + "VkFramebuffer", + "VkRenderPass" ] object_dynamic_state_list = [ - "VK_DYNAMIC_VP_STATE_OBJECT", - "VK_DYNAMIC_RS_STATE_OBJECT", - "VK_DYNAMIC_CB_STATE_OBJECT", - "VK_DYNAMIC_DS_STATE_OBJECT" + "VkDynamicVpStateObject", + "VkDynamicRsStateObject", + "VkDynamicCbStateObject", + "VkDynamicDsStateObject" ] object_type_list = object_root_list + object_base_list + object_list + object_dynamic_state_list -object_parent_list = ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT"] +object_parent_list = ["VkBaseObject", "VkObject", "VkDynamicStateObject"] headers = [] objects = [] @@ -989,8 +989,8 @@ def parse_vk_h(filename): # parse proto_lines to protos protos = [] for line in proto_lines: - first, rest = line.split(" (VKAPI *vk") - second, third = rest.split("Type)(") + first, rest = line.split(" (VKAPI *PFN_vk") + second, third = rest.split(")(") # get the return type, no space before "*" proto_ret = "*".join([t.rstrip() for t in first.split("*")]) -- cgit v1.2.3