+1 -1

src/xrt/auxiliary/vk/vk_bundle_init.c

··· 1239 1239 vk->vkGetDeviceQueue(vk->device, vk->queue_family_index, 0, &vk->queue); 1240 1240 1241 1241 // Need to do this after functions have been gotten. 1242 1242 - VK_NAME_OBJECT(vk, DEVICE, vk->device, "vk_bundle device"); 1242 1242 + VK_NAME_DEVICE(vk, vk->device, "vk_bundle device"); 1243 1243 1244 1244 return ret; 1245 1245

+1 -1

src/xrt/auxiliary/vk/vk_cmd.c

··· 118 118 } 119 119 120 120 // Shortlived, but name for debugging. 121 121 - VK_NAME_OBJECT(vk, FENCE, fence, "VK Submit And Wait"); 121 121 + VK_NAME_FENCE(vk, fence, "VK Submit And Wait"); 122 122 123 123 // Do the submit. 124 124 VkSubmitInfo submitInfo = {

+38 -3

src/xrt/auxiliary/vk/vk_helpers.h

··· 630 630 * 631 631 * @ingroup aux_vk 632 632 */ 633 633 - #define VK_NAME_OBJECT(VK, TYPE, OBJ, NAME) \ 633 633 + #define VK_NAME_OBJ(VK, TYPE, SUFFIX, OBJ, NAME) \ 634 634 do { \ 635 635 if ((VK)->has_EXT_debug_utils) { \ 636 636 - vk_name_object(VK, VK_OBJECT_TYPE_##TYPE, (uint64_t)OBJ, NAME); \ 636 636 + TYPE _thing = OBJ; \ 637 637 + vk_name_object(VK, VK_OBJECT_TYPE_##SUFFIX, (uint64_t)_thing, NAME); \ 637 638 } \ 638 639 } while (false) 640 640 + 639 641 640 642 #else 641 643 642 642 - #define VK_NAME_OBJECT(vk, TYPE, obj name) \ 644 644 + #define VK_NAME_OBJ(VK, TYPE, SUFFIX, OBJ, NAME) \ 643 645 do { \ 646 646 + XRT_MAYBE_UNUSED TYPE _thing = OBJ; \ 644 647 } while (false) 645 648 646 649 #endif 650 650 + 651 651 + // clang-format off 652 652 + #define VK_NAME_INSTANCE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkInstance, INSTANCE, OBJ, NAME) 653 653 + #define VK_NAME_PHYSICAL_DEVICE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPhysicalDevice, PHYSICAL_DEVICE, OBJ, NAME) 654 654 + #define VK_NAME_DEVICE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDevice, DEVICE, OBJ, NAME) 655 655 + #define VK_NAME_QUEUE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkQueue, QUEUE, OBJ, NAME) 656 656 + #define VK_NAME_SEMAPHORE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSemaphore, SEMAPHORE, OBJ, NAME) 657 657 + #define VK_NAME_COMMAND_BUFFER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkCommandBuffer, COMMAND_BUFFER, OBJ, NAME) 658 658 + #define VK_NAME_FENCE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkFence, FENCE, OBJ, NAME) 659 659 + #define VK_NAME_DEVICE_MEMORY(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDeviceMemory, DEVICE_MEMORY, OBJ, NAME) 660 660 + #define VK_NAME_BUFFER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkBuffer, BUFFER, OBJ, NAME) 661 661 + #define VK_NAME_IMAGE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkImage, IMAGE, OBJ, NAME) 662 662 + #define VK_NAME_EVENT(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkEvent, EVENT, OBJ, NAME) 663 663 + #define VK_NAME_QUERY_POOL(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkQueryPool, QUERY_POOL, OBJ, NAME) 664 664 + #define VK_NAME_BUFFER_VIEW(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkBufferView, BUFFER_VIEW, OBJ, NAME) 665 665 + #define VK_NAME_IMAGE_VIEW(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkImageView, IMAGE_VIEW, OBJ, NAME) 666 666 + #define VK_NAME_SHADER_MODULE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkShaderModule, SHADER_MODULE, OBJ, NAME) 667 667 + #define VK_NAME_PIPELINE_CACHE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPipelineCache, PIPELINE_CACHE, OBJ, NAME) 668 668 + #define VK_NAME_PIPELINE_LAYOUT(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPipelineLayout, PIPELINE_LAYOUT, OBJ, NAME) 669 669 + #define VK_NAME_RENDER_PASS(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkRenderPass, RENDER_PASS, OBJ, NAME) 670 670 + #define VK_NAME_PIPELINE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkPipeline, PIPELINE, OBJ, NAME) 671 671 + #define VK_NAME_DESCRIPTOR_SET_LAYOUT(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDescriptorSetLayout, DESCRIPTOR_SET_LAYOUT, OBJ, NAME) 672 672 + #define VK_NAME_SAMPLER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSampler, SAMPLER, OBJ, NAME) 673 673 + #define VK_NAME_DESCRIPTOR_POOL(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDescriptorPool, DESCRIPTOR_POOL, OBJ, NAME) 674 674 + #define VK_NAME_DESCRIPTOR_SET(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkDescriptorSet, DESCRIPTOR_SET, OBJ, NAME) 675 675 + #define VK_NAME_FRAMEBUFFER(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkFramebuffer, FRAMEBUFFER, OBJ, NAME) 676 676 + #define VK_NAME_COMMAND_POOL(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkCommandPool, COMMAND_POOL, OBJ, NAME) 677 677 + 678 678 + #define VK_NAME_SURFACE(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSurfaceKHR, SURFACE_KHR, OBJ, NAME) 679 679 + #define VK_NAME_SWAPCHAIN(VK, OBJ, NAME) VK_NAME_OBJ(VK, VkSwapchainKHR, SWAPCHAIN_KHR, OBJ, NAME) 680 680 + // clang-format on 681 681 + 647 682 648 683 /* 649 684 *

+4 -4

src/xrt/auxiliary/vk/vk_image_allocator.c

··· 308 308 break; 309 309 } 310 310 311 311 - VK_NAME_OBJECT(vk, IMAGE, out_vkic->images[i].handle, "vk_image_collection image"); 312 312 - VK_NAME_OBJECT(vk, DEVICE_MEMORY, out_vkic->images[i].memory, "vk_image_collection device_memory"); 311 311 + VK_NAME_IMAGE(vk, out_vkic->images[i].handle, "vk_image_collection image"); 312 312 + VK_NAME_DEVICE_MEMORY(vk, out_vkic->images[i].memory, "vk_image_collection device_memory"); 313 313 } 314 314 315 315 // Set the fields. ··· 375 375 break; 376 376 } 377 377 378 378 - VK_NAME_OBJECT(vk, IMAGE, out_vkic->images[i].handle, "vk_image_collection image"); 379 379 - VK_NAME_OBJECT(vk, DEVICE_MEMORY, out_vkic->images[i].memory, "vk_image_collection device_memory"); 378 378 + VK_NAME_IMAGE(vk, out_vkic->images[i].handle, "vk_image_collection image"); 379 379 + VK_NAME_DEVICE_MEMORY(vk, out_vkic->images[i].memory, "vk_image_collection device_memory"); 380 380 381 381 native_images[i].handle = buf; 382 382 }

+2 -2

src/xrt/auxiliary/vk/vk_image_readback_to_xf_pool.c

··· 69 69 &memory, // 70 70 &image); // 71 71 72 72 - VK_NAME_OBJECT(vk, DEVICE_MEMORY, memory, "vk_image_readback_to_xf_pool device memory"); 73 73 - VK_NAME_OBJECT(vk, IMAGE, image, "vk_image_readback_to_xf_pool image"); 72 72 + VK_NAME_DEVICE_MEMORY(vk, memory, "vk_image_readback_to_xf_pool device memory"); 73 73 + VK_NAME_IMAGE(vk, image, "vk_image_readback_to_xf_pool image"); 74 74 75 75 (void)res; 76 76

+2 -2

src/xrt/auxiliary/vk/vk_sync_objects.c

··· 135 135 } 136 136 137 137 // Won't be returned, but name for debbuging. 138 138 - VK_NAME_OBJECT(vk, FENCE, fence, "VK Create Submit Sync"); 138 138 + VK_NAME_FENCE(vk, fence, "VK Create Submit Sync"); 139 139 140 140 141 141 /* ··· 352 352 } 353 353 354 354 // Should be overwritten by caller, but name here for debugging. 355 355 - VK_NAME_OBJECT(vk, FENCE, fence, "VK Import"); 355 355 + VK_NAME_FENCE(vk, fence, "VK Import"); 356 356 357 357 358 358 #ifdef XRT_GRAPHICS_SYNC_HANDLE_IS_FD

+6 -6

src/xrt/compositor/client/comp_vk_client.c

··· 119 119 return XRT_ERROR_VULKAN; 120 120 } 121 121 122 122 - VK_NAME_OBJECT(vk, SEMAPHORE, semaphore, "timeline semaphore"); 122 122 + VK_NAME_SEMAPHORE(vk, semaphore, "timeline semaphore"); 123 123 124 124 c->sync.semaphore = semaphore; 125 125 c->sync.xcsem = xcsem; // No need to reference. ··· 672 672 return XRT_ERROR_VULKAN; 673 673 } 674 674 675 675 - VK_NAME_OBJECT(vk, IMAGE, sc->base.images[i], "vk_image_collection image"); 676 676 - VK_NAME_OBJECT(vk, DEVICE_MEMORY, sc->mems[i], "vk_image_collection device_memory"); 675 675 + VK_NAME_IMAGE(vk, sc->base.images[i], "vk_image_collection image"); 676 676 + VK_NAME_DEVICE_MEMORY(vk, sc->mems[i], "vk_image_collection device_memory"); 677 677 } 678 678 679 679 vk_cmd_pool_lock(&c->pool); ··· 686 686 vk_cmd_pool_unlock(&c->pool); 687 687 return XRT_ERROR_VULKAN; 688 688 } 689 689 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, sc->acquire[i], "client_vk_swapchain acquire command buffer"); 689 689 + VK_NAME_COMMAND_BUFFER(vk, sc->acquire[i], "client_vk_swapchain acquire command buffer"); 690 690 ret = vk_cmd_pool_create_and_begin_cmd_buffer_locked(vk, &c->pool, flags, &sc->release[i]); 691 691 if (ret != VK_SUCCESS) { 692 692 vk_cmd_pool_unlock(&c->pool); 693 693 return XRT_ERROR_VULKAN; 694 694 } 695 695 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, sc->release[i], "client_vk_swapchain release command buffer"); 695 695 + VK_NAME_COMMAND_BUFFER(vk, sc->release[i], "client_vk_swapchain release command buffer"); 696 696 697 697 VkImageSubresourceRange subresource_range = { 698 698 .aspectMask = barrier_aspect_mask, ··· 846 846 goto err_mutex; 847 847 } 848 848 849 849 - VK_NAME_OBJECT(&c->vk, COMMAND_POOL, c->pool.pool, "client_vk_compositor command pool"); 849 849 + VK_NAME_COMMAND_POOL(&c->vk, c->pool.pool, "client_vk_compositor command pool"); 850 850 851 851 #ifdef VK_KHR_timeline_semaphore 852 852 if (vk_can_import_and_export_timeline_semaphore(&c->vk)) {

+10 -10

src/xrt/compositor/main/comp_mirror_to_debug_gui.c

··· 184 184 return false; 185 185 } 186 186 187 187 - VK_NAME_OBJECT(vk, IMAGE_VIEW, m->bounce.unorm_view, "comp_mirror_debug_to_gui image view bounce.unorm_view"); 187 187 + VK_NAME_IMAGE_VIEW(vk, m->bounce.unorm_view, "comp_mirror_debug_to_gui image view bounce.unorm_view"); 188 188 189 189 return true; 190 190 } ··· 299 299 return ret; 300 300 } 301 301 302 302 - VK_NAME_OBJECT(vk, COMMAND_POOL, m->cmd_pool.pool, "comp_mirror_to_debug_gui command pool"); 302 302 + VK_NAME_COMMAND_POOL(vk, m->cmd_pool.pool, "comp_mirror_to_debug_gui command pool"); 303 303 304 304 struct vk_descriptor_pool_info blit_pool_info = { 305 305 .uniform_per_descriptor_count = 0, ··· 315 315 &blit_pool_info, // info 316 316 &m->blit.descriptor_pool)); // out_descriptor_pool 317 317 318 318 - VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, m->blit.descriptor_pool, "comp_mirror_to_debug_ui blit descriptor pool"); 318 318 + VK_NAME_DESCRIPTOR_POOL(vk, m->blit.descriptor_pool, "comp_mirror_to_debug_ui blit descriptor pool"); 319 319 320 320 C(vk_create_pipeline_cache(vk, &m->blit.pipeline_cache)); 321 321 322 322 - VK_NAME_OBJECT(vk, PIPELINE_CACHE, m->blit.pipeline_cache, "comp_mirror_to_debug_ui blit pipeline cache"); 322 322 + VK_NAME_PIPELINE_CACHE(vk, m->blit.pipeline_cache, "comp_mirror_to_debug_ui blit pipeline cache"); 323 323 324 324 C(create_blit_descriptor_set_layout(vk, &m->blit.descriptor_set_layout)); 325 325 326 326 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, m->blit.descriptor_set_layout, 327 327 - "comp_mirror_to_debug_ui blit descriptor set layout"); 326 326 + VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, m->blit.descriptor_set_layout, 327 327 + "comp_mirror_to_debug_ui blit descriptor set layout"); 328 328 329 329 C(create_blit_pipeline_layout( // 330 330 vk, // vk_bundle 331 331 m->blit.descriptor_set_layout, // descriptor_set_layout 332 332 &m->blit.pipeline_layout)); // out_pipeline_layout 333 333 334 334 - VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, m->blit.pipeline_layout, "comp_mirror_to_debug_ui blit pipeline layout"); 334 334 + VK_NAME_PIPELINE_LAYOUT(vk, m->blit.pipeline_layout, "comp_mirror_to_debug_ui blit pipeline layout"); 335 335 336 336 C(vk_create_compute_pipeline( // 337 337 vk, // vk_bundle ··· 341 341 NULL, // specialization_info 342 342 &m->blit.pipeline)); // out_compute_pipeline 343 343 344 344 - VK_NAME_OBJECT(vk, PIPELINE, m->blit.pipeline, "comp_mirror_to_debug_ui blit pipeline"); 344 344 + VK_NAME_PIPELINE(vk, m->blit.pipeline, "comp_mirror_to_debug_ui blit pipeline"); 345 345 346 346 return VK_SUCCESS; 347 347 } ··· 446 446 return; 447 447 } 448 448 449 449 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "comp_mirror_to_debug_ui blit descriptor set"); 449 449 + VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "comp_mirror_to_debug_ui blit descriptor set"); 450 450 451 451 struct vk_cmd_pool *pool = &m->cmd_pool; 452 452 ··· 461 461 return; 462 462 } 463 463 464 464 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, cmd, "comp_mirror_to_debug_ui command buffer"); 464 464 + VK_NAME_COMMAND_BUFFER(vk, cmd, "comp_mirror_to_debug_ui command buffer"); 465 465 466 466 // Barrier arguments. 467 467 VkImageSubresourceRange first_color_level_subresource_range = {

+1 -1

src/xrt/compositor/main/comp_renderer.c

··· 363 363 364 364 char buf[] = "Comp Renderer X_XXXX_XXXX"; 365 365 snprintf(buf, ARRAY_SIZE(buf), "Comp Renderer %u", i); 366 366 - VK_NAME_OBJECT(vk, FENCE, r->fences[i], buf); 366 366 + VK_NAME_FENCE(vk, r->fences[i], buf); 367 367 } 368 368 } 369 369

+6 -7

src/xrt/compositor/main/comp_target_swapchain.c

··· 131 131 &cts->base.images[i].view); // out_view 132 132 133 133 134 134 - VK_NAME_OBJECT(vk, IMAGE_VIEW, cts->base.images[i].view, "comp_target_swapchain image view"); 134 134 + VK_NAME_IMAGE_VIEW(vk, cts->base.images[i].view, "comp_target_swapchain image view"); 135 135 } 136 136 137 137 free(images); ··· 452 452 } 453 453 454 454 // Name for debugging. 455 455 - VK_NAME_OBJECT(vk, FENCE, vblank_event_fence, "Comp VBlank"); 455 455 + VK_NAME_FENCE(vk, vblank_event_fence, "Comp VBlank"); 456 456 457 457 // Not scoped to not effect timing. 458 458 COMP_TRACE_IDENT(vblank); ··· 604 604 COMP_ERROR(cts->base.c, "vkCreateSemaphore: %s", vk_result_string(ret)); 605 605 } 606 606 607 607 - VK_NAME_OBJECT(vk, SEMAPHORE, cts->base.semaphores.present_complete, 608 608 - "comp_target_swapchain semaphore present complete"); 607 607 + VK_NAME_SEMAPHORE(vk, cts->base.semaphores.present_complete, 608 608 + "comp_target_swapchain semaphore present complete"); 609 609 610 610 cts->base.semaphores.render_complete_is_timeline = false; 611 611 ret = vk->vkCreateSemaphore(vk->device, &info, NULL, &cts->base.semaphores.render_complete); ··· 613 613 COMP_ERROR(cts->base.c, "vkCreateSemaphore: %s", vk_result_string(ret)); 614 614 } 615 615 616 616 - VK_NAME_OBJECT(vk, SEMAPHORE, cts->base.semaphores.render_complete, 617 617 - "comp_target_swapchain semaphore render complete"); 616 616 + VK_NAME_SEMAPHORE(vk, cts->base.semaphores.render_complete, "comp_target_swapchain semaphore render complete"); 618 617 } 619 618 620 619 ··· 791 790 return; 792 791 } 793 792 794 794 - VK_NAME_OBJECT(vk, SWAPCHAIN_KHR, cts->swapchain.handle, "comp_target_swapchain swapchain"); 793 793 + VK_NAME_SWAPCHAIN(vk, cts->swapchain.handle, "comp_target_swapchain swapchain"); 795 794 796 795 /* 797 796 * Set target info.

+1 -1

src/xrt/compositor/main/comp_window_android.c

··· 125 125 return ret; 126 126 } 127 127 128 128 - VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_android surface"); 128 128 + VK_NAME_SURFACE(vk, surface, "comp_window_android surface"); 129 129 *out_surface = surface; 130 130 131 131 return VK_SUCCESS;

+1 -1

src/xrt/compositor/main/comp_window_direct.c

··· 268 268 return ret; 269 269 } 270 270 271 271 - VK_NAME_OBJECT(get_vk(cts), SURFACE_KHR, surface, "comp_target_swapchain direct surface"); 271 271 + VK_NAME_SURFACE(vk, surface, "comp_target_swapchain direct surface"); 272 272 cts->surface.handle = surface; 273 273 274 274 return VK_SUCCESS;

+1 -1

src/xrt/compositor/main/comp_window_mswin.c

··· 167 167 return ret; 168 168 } 169 169 170 170 - VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_mswin surface"); 170 170 + VK_NAME_SURFACE(vk, surface, "comp_window_mswin surface"); 171 171 *out_surface = surface; 172 172 173 173 return VK_SUCCESS;

+2 -2

src/xrt/compositor/main/comp_window_peek.c

··· 152 152 goto err_free; 153 153 } 154 154 155 155 - VK_NAME_OBJECT(vk, COMMAND_POOL, w->pool.pool, "comp_window_peek command pool"); 155 155 + VK_NAME_COMMAND_POOL(vk, w->pool.pool, "comp_window_peek command pool"); 156 156 157 157 ret = vk_cmd_pool_create_cmd_buffer(vk, &w->pool, &w->cmd); 158 158 if (ret != VK_SUCCESS) { ··· 160 160 goto err_pool; 161 161 } 162 162 163 163 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, w->cmd, "comp_window_peek command buffer"); 163 163 + VK_NAME_COMMAND_BUFFER(vk, w->cmd, "comp_window_peek command buffer"); 164 164 165 165 166 166 /*

+1 -1

src/xrt/compositor/main/comp_window_wayland.c

··· 238 238 return ret; 239 239 } 240 240 241 241 - VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_wayland surface"); 241 241 + VK_NAME_SURFACE(vk, surface, "comp_window_wayland surface"); 242 242 *out_surface = surface; 243 243 244 244 return VK_SUCCESS;

+1 -1

src/xrt/compositor/main/comp_window_xcb.c

··· 423 423 return ret; 424 424 } 425 425 426 426 - VK_NAME_OBJECT(vk, SURFACE_KHR, surface, "comp_window_xcb surface"); 426 426 + VK_NAME_SURFACE(vk, surface, "comp_window_xcb surface"); 427 427 *out_surface = surface; 428 428 429 429 return VK_SUCCESS;

+2 -3

src/xrt/compositor/render/render_compute.c

··· 328 328 &crc->layer_descriptor_sets[i]); // descriptor_set 329 329 VK_CHK_WITH_RET(ret, "vk_create_descriptor_set", false); 330 330 331 331 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, crc->layer_descriptor_sets[i], 332 332 - "render_compute layer descriptor set"); 331 331 + VK_NAME_DESCRIPTOR_SET(vk, crc->layer_descriptor_sets[i], "render_compute layer descriptor set"); 333 332 } 334 333 335 334 ret = vk_create_descriptor_set( // ··· 339 338 &crc->shared_descriptor_set); // descriptor_set 340 339 VK_CHK_WITH_RET(ret, "vk_create_descriptor_set", false); 341 340 342 342 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, crc->shared_descriptor_set, "render_compute shared descriptor set"); 341 341 + VK_NAME_DESCRIPTOR_SET(vk, crc->shared_descriptor_set, "render_compute shared descriptor set"); 343 342 344 343 return true; 345 344 }

+7 -7

src/xrt/compositor/render/render_distortion.c

··· 47 47 &image); // out_image 48 48 VK_CHK_AND_RET(ret, "vk_create_image_simple"); 49 49 50 50 - VK_NAME_OBJECT(vk, DEVICE_MEMORY, device_memory, "distortion device_memory"); 51 51 - VK_NAME_OBJECT(vk, IMAGE, image, "distortion image"); 50 50 + VK_NAME_DEVICE_MEMORY(vk, device_memory, "distortion device_memory"); 51 51 + VK_NAME_IMAGE(vk, image, "distortion image"); 52 52 53 53 VkImageSubresourceRange subresource_range = { 54 54 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, ··· 67 67 &image_view); // out_image_view 68 68 VK_CHK_WITH_GOTO(ret, "vk_create_view", err_free); 69 69 70 70 - VK_NAME_OBJECT(vk, IMAGE_VIEW, image_view, "distortion image view"); 70 70 + VK_NAME_IMAGE_VIEW(vk, image_view, "distortion image view"); 71 71 72 72 *out_device_memory = device_memory; 73 73 *out_image = image; ··· 221 221 222 222 ret = render_buffer_init(vk, r_buffer, usage_flags, properties, size); 223 223 VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers); 224 224 - VK_NAME_OBJECT(vk, BUFFER, r_buffer->buffer, "distortion r_buffer"); 224 224 + VK_NAME_BUFFER(vk, r_buffer->buffer, "distortion r_buffer"); 225 225 ret = render_buffer_init(vk, g_buffer, usage_flags, properties, size); 226 226 VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers); 227 227 - VK_NAME_OBJECT(vk, BUFFER, g_buffer->buffer, "distortion g_buffer"); 227 227 + VK_NAME_BUFFER(vk, g_buffer->buffer, "distortion g_buffer"); 228 228 ret = render_buffer_init(vk, b_buffer, usage_flags, properties, size); 229 229 VK_CHK_WITH_GOTO(ret, "render_buffer_init", err_buffers); 230 230 - VK_NAME_OBJECT(vk, BUFFER, b_buffer->buffer, "distortion b_buffer"); 230 230 + VK_NAME_BUFFER(vk, b_buffer->buffer, "distortion b_buffer"); 231 231 232 232 ret = render_buffer_map(vk, r_buffer); 233 233 VK_CHK_WITH_GOTO(ret, "render_buffer_map", err_buffers); ··· 324 324 325 325 ret = vk_cmd_pool_create_and_begin_cmd_buffer_locked(vk, pool, 0, &upload_buffer); 326 326 VK_CHK_WITH_GOTO(ret, "vk_cmd_pool_create_and_begin_cmd_buffer_locked", err_unlock); 327 327 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, upload_buffer, "render_resources distortion command buffer"); 327 327 + VK_NAME_COMMAND_BUFFER(vk, upload_buffer, "render_resources distortion command buffer"); 328 328 329 329 for (uint32_t i = 0; i < RENDER_DISTORTION_NUM_IMAGES; i++) { 330 330 ret = create_and_queue_upload_locked( //

+19 -20

src/xrt/compositor/render/render_gfx.c

··· 714 714 final_layout, // final_layout 715 715 &rgrp->render_pass); // out_render_pass 716 716 VK_CHK_WITH_RET(ret, "create_implicit_render_pass", false); 717 717 - VK_NAME_OBJECT(vk, RENDER_PASS, rgrp->render_pass, "render_gfx_render_pass render pass"); 717 717 + VK_NAME_RENDER_PASS(vk, rgrp->render_pass, "render_gfx_render_pass render pass"); 718 718 719 719 struct mesh_params simple_params = { 720 720 .do_timewarp = false, ··· 733 733 r->shaders->mesh_frag, // mesh_frag 734 734 &rgrp->mesh.pipeline); // out_mesh_pipeline 735 735 VK_CHK_WITH_RET(ret, "create_mesh_pipeline", false); 736 736 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->mesh.pipeline, "render_gfx_render_pass mesh pipeline"); 736 736 + VK_NAME_PIPELINE(vk, rgrp->mesh.pipeline, "render_gfx_render_pass mesh pipeline"); 737 737 738 738 struct mesh_params timewarp_params = { 739 739 .do_timewarp = true, ··· 752 752 r->shaders->mesh_frag, // mesh_frag 753 753 &rgrp->mesh.pipeline_timewarp); // out_mesh_pipeline 754 754 VK_CHK_WITH_RET(ret, "create_mesh_pipeline", false); 755 755 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->mesh.pipeline_timewarp, "render_gfx_render_pass mesh pipeline timewarp"); 755 755 + VK_NAME_PIPELINE(vk, rgrp->mesh.pipeline_timewarp, "render_gfx_render_pass mesh pipeline timewarp"); 756 756 757 757 const VkBlendFactor blend_factor_premultiplied_alpha = VK_BLEND_FACTOR_ONE; 758 758 const VkBlendFactor blend_factor_unpremultiplied_alpha = VK_BLEND_FACTOR_SRC_ALPHA; ··· 768 768 r->shaders->layer_cylinder_frag, // module_frag 769 769 &rgrp->layer.cylinder_premultiplied_alpha); // out_pipeline 770 770 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 771 771 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.cylinder_premultiplied_alpha, 772 772 - "render_gfx_render_pass cylinder premultiplied alpha"); 771 771 + VK_NAME_PIPELINE(vk, rgrp->layer.cylinder_premultiplied_alpha, 772 772 + "render_gfx_render_pass cylinder premultiplied alpha"); 773 773 774 774 ret = create_layer_pipeline( // 775 775 vk, // vk ··· 781 781 r->shaders->layer_cylinder_frag, // module_frag 782 782 &rgrp->layer.cylinder_unpremultiplied_alpha); // out_pipeline 783 783 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 784 784 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.cylinder_unpremultiplied_alpha, 785 785 - "render_gfx_render_pass cylinder unpremultiplied alpha"); 784 784 + VK_NAME_PIPELINE(vk, rgrp->layer.cylinder_unpremultiplied_alpha, 785 785 + "render_gfx_render_pass cylinder unpremultiplied alpha"); 786 786 787 787 // Equirect2 788 788 ret = create_layer_pipeline( // ··· 795 795 r->shaders->layer_equirect2_frag, // module_frag 796 796 &rgrp->layer.equirect2_premultiplied_alpha); // out_pipeline 797 797 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 798 798 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.equirect2_premultiplied_alpha, 799 799 - "render_gfx_render_pass equirect2 premultiplied alpha"); 798 798 + VK_NAME_PIPELINE(vk, rgrp->layer.equirect2_premultiplied_alpha, 799 799 + "render_gfx_render_pass equirect2 premultiplied alpha"); 800 800 801 801 ret = create_layer_pipeline( // 802 802 vk, // vk ··· 808 808 r->shaders->layer_equirect2_frag, // module_frag 809 809 &rgrp->layer.equirect2_unpremultiplied_alpha); // out_pipeline 810 810 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 811 811 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.equirect2_unpremultiplied_alpha, 812 812 - "render_gfx_render_pass equirect2 unpremultiplied alpha"); 811 811 + VK_NAME_PIPELINE(vk, rgrp->layer.equirect2_unpremultiplied_alpha, 812 812 + "render_gfx_render_pass equirect2 unpremultiplied alpha"); 813 813 814 814 // Projection. 815 815 ret = create_layer_pipeline( // ··· 822 822 r->shaders->layer_shared_frag, // module_frag 823 823 &rgrp->layer.proj_premultiplied_alpha); // out_pipeline 824 824 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 825 825 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.proj_premultiplied_alpha, 826 826 - "render_gfx_render_pass projection premultiplied alpha"); 825 825 + VK_NAME_PIPELINE(vk, rgrp->layer.proj_premultiplied_alpha, 826 826 + "render_gfx_render_pass projection premultiplied alpha"); 827 827 828 828 ret = create_layer_pipeline( // 829 829 vk, // vk ··· 835 835 r->shaders->layer_shared_frag, // module_frag 836 836 &rgrp->layer.proj_unpremultiplied_alpha); // out_pipeline 837 837 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 838 838 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.proj_unpremultiplied_alpha, 839 839 - "render_gfx_render_pass projection unpremultiplied alpha"); 838 838 + VK_NAME_PIPELINE(vk, rgrp->layer.proj_unpremultiplied_alpha, 839 839 + "render_gfx_render_pass projection unpremultiplied alpha"); 840 840 841 841 // Quad 842 842 ret = create_layer_pipeline( // ··· 849 849 r->shaders->layer_shared_frag, // module_frag 850 850 &rgrp->layer.quad_premultiplied_alpha); // out_pipeline 851 851 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 852 852 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.quad_premultiplied_alpha, 853 853 - "render_gfx_render_pass quad premultiplied alpha"); 852 852 + VK_NAME_PIPELINE(vk, rgrp->layer.quad_premultiplied_alpha, "render_gfx_render_pass quad premultiplied alpha"); 854 853 855 854 ret = create_layer_pipeline( // 856 855 vk, // vk ··· 862 861 r->shaders->layer_shared_frag, // module_frag 863 862 &rgrp->layer.quad_unpremultiplied_alpha); // out_pipeline 864 863 VK_CHK_WITH_RET(ret, "create_layer_pipeline", false); 865 865 - VK_NAME_OBJECT(vk, PIPELINE, rgrp->layer.quad_unpremultiplied_alpha, 866 866 - "render_gfx_render_pass quad unpremultiplied alpha"); 864 864 + VK_NAME_PIPELINE(vk, rgrp->layer.quad_unpremultiplied_alpha, 865 865 + "render_gfx_render_pass quad unpremultiplied alpha"); 867 866 868 867 // Set fields. 869 868 rgrp->r = r; ··· 922 921 extent.height, // height, 923 922 &rtr->framebuffer); // out_external_framebuffer 924 923 VK_CHK_WITH_RET(ret, "create_framebuffer", false); 925 925 - VK_NAME_OBJECT(vk, FRAMEBUFFER, rtr->framebuffer, "render_gfx_target_resources framebuffer"); 924 924 + VK_NAME_FRAMEBUFFER(vk, rtr->framebuffer, "render_gfx_target_resources framebuffer"); 926 925 927 926 // Set fields. 928 927 rtr->rgrp = rgrp;

+48 -52

src/xrt/compositor/render/render_resources.c

··· 108 108 memory_property_flags, // memory_property_flags 109 109 vbo_size); // size 110 110 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 111 111 - VK_NAME_OBJECT(vk, BUFFER, vbo->buffer, "mesh vbo"); 111 111 + VK_NAME_BUFFER(vk, vbo->buffer, "mesh vbo"); 112 112 113 113 ret = render_buffer_write( // 114 114 vk, // vk_bundle ··· 130 130 memory_property_flags, // memory_property_flags 131 131 ibo_size); // size 132 132 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 133 133 - VK_NAME_OBJECT(vk, BUFFER, ibo->buffer, "mesh ibo"); 133 133 + VK_NAME_BUFFER(vk, ibo->buffer, "mesh ibo"); 134 134 135 135 ret = render_buffer_write( // 136 136 vk, // vk_bundle ··· 161 161 memory_property_flags, // 162 162 ubo_size); // size 163 163 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 164 164 - VK_NAME_OBJECT(vk, BUFFER, l_ubo->buffer, "mesh l_ubo"); 164 164 + VK_NAME_BUFFER(vk, l_ubo->buffer, "mesh l_ubo"); 165 165 166 166 ret = render_buffer_map(vk, l_ubo); 167 167 VK_CHK_WITH_RET(ret, "render_buffer_map", false); ··· 172 172 memory_property_flags, // 173 173 ubo_size); // size 174 174 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 175 175 - VK_NAME_OBJECT(vk, BUFFER, r_ubo->buffer, "mesh r_ubo"); 175 175 + VK_NAME_BUFFER(vk, r_ubo->buffer, "mesh r_ubo"); 176 176 177 177 ret = render_buffer_map(vk, r_ubo); 178 178 VK_CHK_WITH_RET(ret, "render_buffer_map", false); ··· 452 452 &image); // out_image 453 453 VK_CHK_WITH_RET(ret, "vk_create_image_mutable_rgba", false); 454 454 455 455 - VK_NAME_OBJECT(vk, DEVICE_MEMORY, device_memory, "render_scratch_color_image device_memory"); 456 456 - VK_NAME_OBJECT(vk, IMAGE, image, "render_scratch_color_image image"); 455 455 + VK_NAME_DEVICE_MEMORY(vk, device_memory, "render_scratch_color_image device_memory"); 456 456 + VK_NAME_IMAGE(vk, image, "render_scratch_color_image image"); 457 457 458 458 VkImageSubresourceRange subresource_range = { 459 459 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, ··· 473 473 &srgb_view); // out_image_view 474 474 VK_CHK_WITH_RET(ret, "vk_create_view_usage", false); 475 475 476 476 - VK_NAME_OBJECT(vk, IMAGE_VIEW, srgb_view, "render_scratch_color_image image view srgb"); 476 476 + VK_NAME_IMAGE_VIEW(vk, srgb_view, "render_scratch_color_image image view srgb"); 477 477 478 478 ret = vk_create_view_usage( // 479 479 vk, // vk_bundle ··· 485 485 &unorm_view); // out_image_view 486 486 VK_CHK_WITH_RET(ret, "vk_create_view_usage", false); 487 487 488 488 - VK_NAME_OBJECT(vk, IMAGE_VIEW, unorm_view, "render_scratch_color_image image view unorm"); 488 488 + VK_NAME_IMAGE_VIEW(vk, unorm_view, "render_scratch_color_image image view unorm"); 489 489 490 490 rsci->device_memory = device_memory; 491 491 rsci->image = image; ··· 564 564 &r->samplers.mock); // out_sampler 565 565 VK_CHK_WITH_RET(ret, "vk_create_sampler", false); 566 566 567 567 - VK_NAME_OBJECT(vk, SAMPLER, r->samplers.mock, "render_resources sampler mock"); 567 567 + VK_NAME_SAMPLER(vk, r->samplers.mock, "render_resources sampler mock"); 568 568 569 569 ret = vk_create_sampler( // 570 570 vk, // vk_bundle ··· 572 572 &r->samplers.repeat); // out_sampler 573 573 VK_CHK_WITH_RET(ret, "vk_create_sampler", false); 574 574 575 575 - VK_NAME_OBJECT(vk, SAMPLER, r->samplers.repeat, "render_resources sampler repeat"); 575 575 + VK_NAME_SAMPLER(vk, r->samplers.repeat, "render_resources sampler repeat"); 576 576 577 577 ret = vk_create_sampler( // 578 578 vk, // vk_bundle ··· 580 580 &r->samplers.clamp_to_edge); // out_sampler 581 581 VK_CHK_WITH_RET(ret, "vk_create_sampler", false); 582 582 583 583 - VK_NAME_OBJECT(vk, SAMPLER, r->samplers.clamp_to_edge, "render_resources sampler clamp_to_edge"); 583 583 + VK_NAME_SAMPLER(vk, r->samplers.clamp_to_edge, "render_resources sampler clamp_to_edge"); 584 584 585 585 ret = vk_create_sampler( // 586 586 vk, // vk_bundle ··· 588 588 &r->samplers.clamp_to_border_black); // out_sampler 589 589 VK_CHK_WITH_RET(ret, "vk_create_sampler", false); 590 590 591 591 - VK_NAME_OBJECT(vk, SAMPLER, r->samplers.clamp_to_border_black, 592 592 - "render_resources sampler clamp_to_border_black"); 591 591 + VK_NAME_SAMPLER(vk, r->samplers.clamp_to_border_black, "render_resources sampler clamp_to_border_black"); 593 592 594 593 595 594 /* ··· 599 598 ret = vk_cmd_pool_init(vk, &r->distortion_pool, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT); 600 599 VK_CHK_WITH_RET(ret, "vk_cmd_pool_init", false); 601 600 602 602 - VK_NAME_OBJECT(vk, COMMAND_POOL, r->distortion_pool.pool, "render_resources distortion command pool"); 601 601 + VK_NAME_COMMAND_POOL(vk, r->distortion_pool.pool, "render_resources distortion command pool"); 603 602 604 603 VkCommandPoolCreateInfo command_pool_info = { 605 604 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, ··· 610 609 ret = vk->vkCreateCommandPool(vk->device, &command_pool_info, NULL, &r->cmd_pool); 611 610 VK_CHK_WITH_RET(ret, "vkCreateCommandPool", false); 612 611 613 613 - VK_NAME_OBJECT(vk, COMMAND_POOL, r->cmd_pool, "render_resources command pool"); 612 612 + VK_NAME_COMMAND_POOL(vk, r->cmd_pool, "render_resources command pool"); 614 613 615 614 616 615 /* ··· 639 638 &r->mock.color.image); // out_image 640 639 VK_CHK_WITH_RET(ret, "vk_create_image_simple", false); 641 640 642 642 - VK_NAME_OBJECT(vk, DEVICE_MEMORY, r->mock.color.memory, "render_resources mock color device memory"); 643 643 - VK_NAME_OBJECT(vk, IMAGE, r->mock.color.image, "render_resources mock color image"); 641 641 + VK_NAME_DEVICE_MEMORY(vk, r->mock.color.memory, "render_resources mock color device memory"); 642 642 + VK_NAME_IMAGE(vk, r->mock.color.image, "render_resources mock color image"); 644 643 645 644 ret = vk_create_view( // 646 645 vk, // vk_bundle ··· 651 650 &r->mock.color.image_view); // out_view 652 651 VK_CHK_WITH_RET(ret, "vk_create_view", false); 653 652 654 654 - VK_NAME_OBJECT(vk, IMAGE_VIEW, r->mock.color.image_view, "render_resources mock color image view"); 653 653 + VK_NAME_IMAGE_VIEW(vk, r->mock.color.image_view, "render_resources mock color image view"); 655 654 656 655 657 656 VkCommandBuffer cmd = VK_NULL_HANDLE; 658 657 ret = vk_cmd_create_and_begin_cmd_buffer_locked(vk, r->cmd_pool, 0, &cmd); 659 658 VK_CHK_WITH_RET(ret, "vk_cmd_create_and_begin_cmd_buffer_locked", false); 660 659 661 661 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, cmd, "render_resources mock command buffer"); 660 660 + VK_NAME_COMMAND_BUFFER(vk, cmd, "render_resources mock command buffer"); 662 661 663 662 ret = prepare_mock_image_locked( // 664 663 vk, // vk_bundle ··· 680 679 ret = vk_create_pipeline_cache(vk, &r->pipeline_cache); 681 680 VK_CHK_WITH_RET(ret, "vk_create_pipeline_cache", false); 682 681 683 683 - VK_NAME_OBJECT(vk, PIPELINE_CACHE, r->pipeline_cache, "render_resources pipeline cache"); 682 682 + VK_NAME_PIPELINE_CACHE(vk, r->pipeline_cache, "render_resources pipeline cache"); 684 683 685 684 VkCommandBufferAllocateInfo cmd_buffer_info = { 686 685 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, ··· 695 694 &r->cmd); // pCommandBuffers 696 695 VK_CHK_WITH_RET(ret, "vkAllocateCommandBuffers", false); 697 696 698 698 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, r->cmd, "render_resources command buffer"); 697 697 + VK_NAME_COMMAND_BUFFER(vk, r->cmd, "render_resources command buffer"); 699 698 700 699 701 700 /* ··· 724 723 &r->gfx.ubo_and_src_descriptor_pool); // out_descriptor_pool 725 724 VK_CHK_WITH_RET(ret, "vk_create_descriptor_pool", false); 726 725 727 727 - VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, r->gfx.ubo_and_src_descriptor_pool, 728 728 - "render_resources ubo and src descriptor pool"); 726 726 + VK_NAME_DESCRIPTOR_POOL(vk, r->gfx.ubo_and_src_descriptor_pool, 727 727 + "render_resources ubo and src descriptor pool"); 729 728 730 729 VkBufferUsageFlags usage_flags = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; 731 730 VkMemoryPropertyFlags memory_property_flags = // ··· 753 752 memory_property_flags, // memory_property_flags 754 753 size); // size 755 754 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 756 756 - VK_NAME_OBJECT(vk, BUFFER, r->gfx.shared_ubo.buffer, "render_resources gfx shared ubo"); 755 755 + VK_NAME_BUFFER(vk, r->gfx.shared_ubo.buffer, "render_resources gfx shared ubo"); 757 756 758 757 ret = render_buffer_map( // 759 758 vk, // vk_bundle ··· 773 772 &r->gfx.layer.shared.descriptor_set_layout); // out_descriptor_set_layout 774 773 VK_CHK_WITH_RET(ret, "create_gfx_ubo_and_src_descriptor_set_layout", false); 775 774 776 776 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->gfx.layer.shared.descriptor_set_layout, 777 777 - "render_resources gfx layer shared descriptor set layout"); 775 775 + VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->gfx.layer.shared.descriptor_set_layout, 776 776 + "render_resources gfx layer shared descriptor set layout"); 778 777 779 778 ret = vk_create_pipeline_layout( // 780 779 vk, // vk_bundle ··· 782 781 &r->gfx.layer.shared.pipeline_layout); // out_pipeline_layout 783 782 VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false); 784 783 785 785 - VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->gfx.layer.shared.pipeline_layout, 786 786 - "render_resources gfx layer shared pipeline layout"); 784 784 + VK_NAME_PIPELINE_LAYOUT(vk, r->gfx.layer.shared.pipeline_layout, 785 785 + "render_resources gfx layer shared pipeline layout"); 787 786 788 787 789 788 /* ··· 797 796 &r->mesh.descriptor_set_layout); // out_mesh_descriptor_set_layout 798 797 VK_CHK_WITH_RET(ret, "create_gfx_ubo_and_src_descriptor_set_layout", false); 799 798 800 800 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->mesh.descriptor_set_layout, 801 801 - "render_resources mesh descriptor set layout"); 799 799 + VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->mesh.descriptor_set_layout, "render_resources mesh descriptor set layout"); 802 800 803 801 ret = vk_create_pipeline_layout( // 804 802 vk, // vk_bundle ··· 806 804 &r->mesh.pipeline_layout); // out_pipeline_layout 807 805 VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false); 808 806 809 809 - VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->mesh.pipeline_layout, "render_resources mesh pipeline layout"); 807 807 + VK_NAME_PIPELINE_LAYOUT(vk, r->mesh.pipeline_layout, "render_resources mesh pipeline layout"); 810 808 811 809 bret = init_mesh_vertex_buffers( // 812 810 vk, // ··· 858 856 &r->compute.descriptor_pool); // out_descriptor_pool 859 857 VK_CHK_WITH_RET(ret, "vk_create_descriptor_pool", false); 860 858 861 861 - VK_NAME_OBJECT(vk, DESCRIPTOR_POOL, r->compute.descriptor_pool, "render_resources compute descriptor pool"); 859 859 + VK_NAME_DESCRIPTOR_POOL(vk, r->compute.descriptor_pool, "render_resources compute descriptor pool"); 862 860 863 861 /* 864 862 * Layer pipeline ··· 873 871 &r->compute.layer.descriptor_set_layout); // out_descriptor_set_layout 874 872 VK_CHK_WITH_RET(ret, "create_compute_layer_descriptor_set_layout", false); 875 873 876 876 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->compute.layer.descriptor_set_layout, 877 877 - "render_resources compute layer descriptor set layout"); 874 874 + VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->compute.layer.descriptor_set_layout, 875 875 + "render_resources compute layer descriptor set layout"); 878 876 879 877 ret = vk_create_pipeline_layout( // 880 878 vk, // vk_bundle ··· 882 880 &r->compute.layer.pipeline_layout); // out_pipeline_layout 883 881 VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false); 884 882 885 885 - VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->compute.layer.pipeline_layout, 886 886 - "render_resources compute layer pipeline layout"); 883 883 + VK_NAME_PIPELINE_LAYOUT(vk, r->compute.layer.pipeline_layout, "render_resources compute layer pipeline layout"); 887 884 888 885 struct compute_layer_params layer_params = { 889 886 .do_timewarp = false, ··· 901 898 &r->compute.layer.non_timewarp_pipeline); // out_compute_pipeline 902 899 VK_CHK_WITH_RET(ret, "create_compute_layer_pipeline", false); 903 900 904 904 - VK_NAME_OBJECT(vk, PIPELINE, r->compute.layer.non_timewarp_pipeline, 905 905 - "render_resources compute layer non timewarp pipeline"); 901 901 + VK_NAME_PIPELINE(vk, r->compute.layer.non_timewarp_pipeline, 902 902 + "render_resources compute layer non timewarp pipeline"); 906 903 907 904 struct compute_layer_params layer_timewarp_params = { 908 905 .do_timewarp = true, ··· 920 917 &r->compute.layer.timewarp_pipeline); // out_compute_pipeline 921 918 VK_CHK_WITH_RET(ret, "create_compute_layer_pipeline", false); 922 919 923 923 - VK_NAME_OBJECT(vk, PIPELINE, r->compute.layer.timewarp_pipeline, 924 924 - "render_resources compute layer timewarp pipeline"); 920 920 + VK_NAME_PIPELINE(vk, r->compute.layer.timewarp_pipeline, "render_resources compute layer timewarp pipeline"); 925 921 926 922 size_t layer_ubo_size = sizeof(struct render_compute_layer_ubo_data); 927 923 ··· 933 929 memory_property_flags, // memory_property_flags 934 930 layer_ubo_size); // size 935 931 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 936 936 - VK_NAME_OBJECT(vk, BUFFER, r->compute.layer.ubos[i].buffer, "render_resources compute layer ubo"); 932 932 + VK_NAME_BUFFER(vk, r->compute.layer.ubos[i].buffer, "render_resources compute layer ubo"); 937 933 938 934 ret = render_buffer_map( // 939 935 vk, // vk_bundle ··· 955 951 &r->compute.distortion.descriptor_set_layout); // out_descriptor_set_layout 956 952 VK_CHK_WITH_RET(ret, "create_compute_distortion_descriptor_set_layout", false); 957 953 958 958 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET_LAYOUT, r->compute.distortion.descriptor_set_layout, 959 959 - "render_resources compute distortion descriptor set layout"); 954 954 + VK_NAME_DESCRIPTOR_SET_LAYOUT(vk, r->compute.distortion.descriptor_set_layout, 955 955 + "render_resources compute distortion descriptor set layout"); 960 956 961 957 ret = vk_create_pipeline_layout( // 962 958 vk, // vk_bundle ··· 964 960 &r->compute.distortion.pipeline_layout); // out_pipeline_layout 965 961 VK_CHK_WITH_RET(ret, "vk_create_pipeline_layout", false); 966 962 967 967 - VK_NAME_OBJECT(vk, PIPELINE_LAYOUT, r->compute.distortion.pipeline_layout, 968 968 - "render_resources compute distortion pipeline layout"); 963 963 + VK_NAME_PIPELINE_LAYOUT(vk, r->compute.distortion.pipeline_layout, 964 964 + "render_resources compute distortion pipeline layout"); 969 965 970 966 struct compute_distortion_params distortion_params = { 971 967 .distortion_texel_count = RENDER_DISTORTION_IMAGE_DIMENSIONS, ··· 981 977 &r->compute.distortion.pipeline); // out_compute_pipeline 982 978 VK_CHK_WITH_RET(ret, "create_compute_distortion_pipeline", false); 983 979 984 984 - VK_NAME_OBJECT(vk, PIPELINE, r->compute.distortion.pipeline, "render_resources compute distortion pipeline"); 980 980 + VK_NAME_PIPELINE(vk, r->compute.distortion.pipeline, "render_resources compute distortion pipeline"); 985 981 986 982 struct compute_distortion_params distortion_timewarp_params = { 987 983 .distortion_texel_count = RENDER_DISTORTION_IMAGE_DIMENSIONS, ··· 997 993 &r->compute.distortion.timewarp_pipeline); // out_compute_pipeline 998 994 VK_CHK_WITH_RET(ret, "create_compute_distortion_pipeline", false); 999 995 1000 1000 - VK_NAME_OBJECT(vk, PIPELINE, r->compute.distortion.timewarp_pipeline, 1001 1001 - "render_resources compute distortion timewarp pipeline"); 996 996 + VK_NAME_PIPELINE(vk, r->compute.distortion.timewarp_pipeline, 997 997 + "render_resources compute distortion timewarp pipeline"); 1002 998 1003 999 size_t distortion_ubo_size = sizeof(struct render_compute_distortion_ubo_data); 1004 1000 ··· 1009 1005 memory_property_flags, // memory_property_flags 1010 1006 distortion_ubo_size); // size 1011 1007 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 1012 1012 - VK_NAME_OBJECT(vk, BUFFER, r->compute.distortion.ubo.buffer, "render_resources compute distortion ubo"); 1008 1008 + VK_NAME_BUFFER(vk, r->compute.distortion.ubo.buffer, "render_resources compute distortion ubo"); 1013 1009 ret = render_buffer_map( // 1014 1010 vk, // vk_bundle 1015 1011 &r->compute.distortion.ubo); // buffer ··· 1029 1025 &r->compute.clear.pipeline); // out_compute_pipeline 1030 1026 VK_CHK_WITH_RET(ret, "vk_create_compute_pipeline", false); 1031 1027 1032 1032 - VK_NAME_OBJECT(vk, PIPELINE, r->compute.clear.pipeline, "render_resources compute clear pipeline"); 1028 1028 + VK_NAME_PIPELINE(vk, r->compute.clear.pipeline, "render_resources compute clear pipeline"); 1033 1029 1034 1030 size_t clear_ubo_size = sizeof(struct render_compute_distortion_ubo_data); 1035 1031 ··· 1040 1036 memory_property_flags, // memory_property_flags 1041 1037 clear_ubo_size); // size 1042 1038 VK_CHK_WITH_RET(ret, "render_buffer_init", false); 1043 1043 - VK_NAME_OBJECT(vk, BUFFER, r->compute.clear.ubo.buffer, "render_resources compute clear ubo"); 1039 1039 + VK_NAME_BUFFER(vk, r->compute.clear.ubo.buffer, "render_resources compute clear ubo"); 1044 1040 1045 1041 ret = render_buffer_map( // 1046 1042 vk, // vk_bundle ··· 1082 1078 NULL, // pAllocator 1083 1079 &r->query_pool); // pQueryPool 1084 1080 1085 1085 - VK_NAME_OBJECT(vk, QUERY_POOL, r->query_pool, "render_resources query pool"); 1081 1081 + VK_NAME_QUERY_POOL(vk, r->query_pool, "render_resources query pool"); 1086 1082 1087 1083 /* 1088 1084 * Done

+1 -1

src/xrt/compositor/render/render_shaders.c

··· 70 70 render_shaders_close(s, vk); \ 71 71 return false; \ 72 72 } \ 73 73 - VK_NAME_OBJECT(vk, SHADER_MODULE, s->SHADER, #SHADER); \ 73 73 + VK_NAME_SHADER_MODULE(vk, s->SHADER, #SHADER); \ 74 74 } while (false) 75 75 76 76

+5 -5

src/xrt/compositor/util/comp_render_gfx.c

··· 220 220 &descriptor_set); // out_descriptor_set 221 221 VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); 222 222 223 223 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set"); 223 223 + VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set"); 224 224 225 225 add_layer(state, layer_data, descriptor_set); 226 226 ··· 284 284 &descriptor_set); // out_descriptor_set 285 285 VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); 286 286 287 287 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set"); 287 287 + VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set"); 288 288 289 289 add_layer(state, layer_data, descriptor_set); 290 290 ··· 346 346 &descriptor_set); // out_descriptor_set 347 347 VK_CHK_AND_RET(ret, "render_gfx_layer_projection_alloc_and_write"); 348 348 349 349 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set"); 349 349 + VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set"); 350 350 351 351 add_layer(state, layer_data, descriptor_set); 352 352 ··· 397 397 &descriptor_set); // out_descriptor_set 398 398 VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); 399 399 400 400 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_set, "render_gfx layer quad descriptor set"); 400 400 + VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "render_gfx layer quad descriptor set"); 401 401 402 402 add_layer(state, layer_data, descriptor_set); 403 403 ··· 638 638 &descriptor_sets[i]); // 639 639 VK_CHK_WITH_GOTO(ret, "render_gfx_mesh_alloc", err_no_memory); 640 640 641 641 - VK_NAME_OBJECT(vk, DESCRIPTOR_SET, descriptor_sets[i], "render_gfx mesh descriptor sets"); 641 641 + VK_NAME_DESCRIPTOR_SET(vk, descriptor_sets[i], "render_gfx mesh descriptor sets"); 642 642 } 643 643 644 644

+1 -1

src/xrt/compositor/util/comp_semaphore.c

··· 97 97 return XRT_ERROR_VULKAN; 98 98 } 99 99 100 100 - VK_NAME_OBJECT(vk, SEMAPHORE, semaphore, "comp_semaphore timeline"); 100 100 + VK_NAME_SEMAPHORE(vk, semaphore, "comp_semaphore timeline"); 101 101 102 102 struct comp_semaphore *csem = U_TYPED_CALLOC(struct comp_semaphore); 103 103

+4 -5

src/xrt/compositor/util/comp_swapchain.c

··· 292 292 subresource_range, // subresource_range 293 293 &sc->images[i].views.alpha[layer]); // out_view 294 294 295 295 - VK_NAME_OBJECT(vk, IMAGE_VIEW, sc->images[i].views.alpha[layer], 296 296 - "comp_swapchain views alpha layer"); 295 295 + VK_NAME_IMAGE_VIEW(vk, sc->images[i].views.alpha[layer], "comp_swapchain views alpha layer"); 297 296 298 297 vk_create_view_swizzle( // 299 298 vk, // vk ··· 304 303 components, // components 305 304 &sc->images[i].views.no_alpha[layer]); // out_view 306 305 307 307 - VK_NAME_OBJECT(vk, IMAGE_VIEW, sc->images[i].views.no_alpha[layer], 308 308 - "comp_swapchain views no alpha layer"); 306 306 + VK_NAME_IMAGE_VIEW(vk, sc->images[i].views.no_alpha[layer], 307 307 + "comp_swapchain views no alpha layer"); 309 308 } 310 309 } 311 310 ··· 335 334 return; 336 335 } 337 336 338 338 - VK_NAME_OBJECT(vk, COMMAND_BUFFER, cmd_buffer, "comp_swapchain command buffer"); 337 337 + VK_NAME_COMMAND_BUFFER(vk, cmd_buffer, "comp_swapchain command buffer"); 339 338 340 339 VkImageAspectFlagBits image_barrier_aspect = vk_csci_get_barrier_aspect_mask(image_view_format); 341 340

+1 -1

src/xrt/compositor/util/comp_sync.c

··· 109 109 } 110 110 111 111 // Name for debugging. 112 112 - VK_NAME_OBJECT(vk, FENCE, fence, "Comp Sync"); 112 112 + VK_NAME_FENCE(vk, fence, "Comp Sync"); 113 113 114 114 struct fence *f = U_TYPED_CALLOC(struct fence); 115 115 f->base.wait = fence_wait;

+1 -1

src/xrt/compositor/util/comp_vulkan.c

··· 232 232 return ret; 233 233 } 234 234 235 235 - VK_NAME_OBJECT(vk, INSTANCE, vk->instance, "monado vulkan instance"); 235 235 + VK_NAME_INSTANCE(vk, vk->instance, "monado vulkan instance"); 236 236 237 237 /* 238 238 * Post creation setup of Vulkan bundle.