The open source OpenXR runtime
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

c/render: Use new Vulkan helpers

+49 -408
+5 -118
src/xrt/compositor/render/comp_compute.c
··· 85 85 * 86 86 */ 87 87 88 - static VkResult 89 - create_command_buffer(struct vk_bundle *vk, VkCommandBuffer *out_cmd) 90 - { 91 - VkResult ret; 92 - 93 - VkCommandBufferAllocateInfo cmd_buffer_info = { 94 - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, 95 - .commandPool = vk->cmd_pool, 96 - .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 97 - .commandBufferCount = 1, 98 - }; 99 - 100 - VkCommandBuffer cmd = VK_NULL_HANDLE; 101 - 102 - os_mutex_lock(&vk->cmd_pool_mutex); 103 - 104 - ret = vk->vkAllocateCommandBuffers( // 105 - vk->device, // 106 - &cmd_buffer_info, // 107 - &cmd); // 108 - 109 - os_mutex_unlock(&vk->cmd_pool_mutex); 110 - 111 - if (ret != VK_SUCCESS) { 112 - VK_ERROR(vk, "vkCreateFramebuffer failed: %s", vk_result_string(ret)); 113 - return ret; 114 - } 115 - 116 - *out_cmd = cmd; 117 - 118 - return VK_SUCCESS; 119 - } 120 - 121 - static void 122 - destroy_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer) 123 - { 124 - os_mutex_lock(&vk->cmd_pool_mutex); 125 - 126 - vk->vkFreeCommandBuffers( // 127 - vk->device, // device 128 - vk->cmd_pool, // commandPool 129 - 1, // commandBufferCount 130 - &command_buffer); // pCommandBuffers 131 - 132 - os_mutex_unlock(&vk->cmd_pool_mutex); 133 - } 134 - 135 - static VkResult 136 - begin_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer) 137 - { 138 - VkResult ret; 139 - 140 - VkCommandBufferBeginInfo command_buffer_info = { 141 - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, 142 - }; 143 - 144 - ret = vk->vkBeginCommandBuffer( // 145 - command_buffer, // 146 - &command_buffer_info); // 147 - if (ret != VK_SUCCESS) { 148 - VK_ERROR(vk, "vkBeginCommandBuffer failed: %s", vk_result_string(ret)); 149 - return ret; 150 - } 151 - 152 - return VK_SUCCESS; 153 - } 154 - 155 - static VkResult 156 - end_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer) 157 - { 158 - VkResult ret; 159 - 160 - // End the command buffer. 161 - ret = vk->vkEndCommandBuffer( // 162 - command_buffer); // 163 - if (ret != VK_SUCCESS) { 164 - VK_ERROR(vk, "vkEndCommandBuffer failed: %s", vk_result_string(ret)); 165 - return ret; 166 - } 167 - 168 - return VK_SUCCESS; 169 - } 170 - 171 - static VkResult 172 - create_descriptor_set(struct vk_bundle *vk, 173 - VkDescriptorPool descriptor_pool, 174 - VkDescriptorSetLayout descriptor_layout, 175 - VkDescriptorSet *out_descriptor_set) 176 - { 177 - VkResult ret; 178 - 179 - VkDescriptorSetAllocateInfo alloc_info = { 180 - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 181 - .descriptorPool = descriptor_pool, 182 - .descriptorSetCount = 1, 183 - .pSetLayouts = &descriptor_layout, 184 - }; 185 - 186 - VkDescriptorSet descriptor_set = VK_NULL_HANDLE; 187 - ret = vk->vkAllocateDescriptorSets( // 188 - vk->device, // 189 - &alloc_info, // 190 - &descriptor_set); // 191 - if (ret != VK_SUCCESS) { 192 - VK_DEBUG(vk, "vkAllocateDescriptorSets failed: %s", vk_result_string(ret)); 193 - return ret; 194 - } 195 - 196 - *out_descriptor_set = descriptor_set; 197 - 198 - return VK_SUCCESS; 199 - } 200 - 201 88 XRT_MAYBE_UNUSED static void 202 89 update_compute_discriptor_set(struct vk_bundle *vk, 203 90 uint32_t src_binding, ··· 375 262 struct vk_bundle *vk = r->vk; 376 263 crc->r = r; 377 264 378 - C(create_command_buffer(vk, &crc->cmd)); 265 + C(vk_create_command_buffer(vk, &crc->cmd)); 379 266 380 - C(create_descriptor_set( // 267 + C(vk_create_descriptor_set( // 381 268 vk, // 382 269 r->compute.descriptor_pool, // descriptor_pool 383 270 r->compute.descriptor_set_layout, // descriptor_set_layout ··· 391 278 { 392 279 struct vk_bundle *vk = vk_from_crc(crc); 393 280 394 - C(begin_command_buffer(vk, crc->cmd)); 281 + C(vk_begin_command_buffer(vk, crc->cmd)); 395 282 396 283 return true; 397 284 } ··· 401 288 { 402 289 struct vk_bundle *vk = vk_from_crc(crc); 403 290 404 - C(end_command_buffer(vk, crc->cmd)); 291 + C(vk_end_command_buffer(vk, crc->cmd)); 405 292 406 293 return true; 407 294 } ··· 413 300 414 301 struct vk_bundle *vk = vk_from_crc(crc); 415 302 416 - destroy_command_buffer(vk, crc->cmd); 303 + vk_destroy_command_buffer(vk, crc->cmd); 417 304 418 305 // Reclaimed by vkResetDescriptorPool. 419 306 crc->descriptor_set = VK_NULL_HANDLE;
+6 -105
src/xrt/compositor/render/comp_rendering.c
··· 131 131 } 132 132 133 133 static VkResult 134 - create_descriptor_set(struct vk_bundle *vk, 135 - VkDescriptorPool descriptor_pool, 136 - VkDescriptorSetLayout descriptor_layout, 137 - VkDescriptorSet *out_descriptor_set) 138 - { 139 - VkResult ret; 140 - 141 - VkDescriptorSetAllocateInfo alloc_info = { 142 - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 143 - .descriptorPool = descriptor_pool, 144 - .descriptorSetCount = 1, 145 - .pSetLayouts = &descriptor_layout, 146 - }; 147 - 148 - VkDescriptorSet descriptor_set = VK_NULL_HANDLE; 149 - ret = vk->vkAllocateDescriptorSets(vk->device, // 150 - &alloc_info, // 151 - &descriptor_set); // 152 - if (ret != VK_SUCCESS) { 153 - VK_DEBUG(vk, "vkAllocateDescriptorSets failed: %s", vk_result_string(ret)); 154 - return ret; 155 - } 156 - 157 - *out_descriptor_set = descriptor_set; 158 - 159 - return VK_SUCCESS; 160 - } 161 - 162 - static VkResult 163 134 create_framebuffer(struct vk_bundle *vk, 164 135 VkImageView image_view, 165 136 VkRenderPass render_pass, ··· 192 163 } 193 164 194 165 *out_external_framebuffer = framebuffer; 195 - 196 - return VK_SUCCESS; 197 - } 198 - 199 - static VkResult 200 - create_command_buffer(struct vk_bundle *vk, VkCommandBuffer *out_cmd) 201 - { 202 - VkResult ret; 203 - 204 - VkCommandBufferAllocateInfo cmd_buffer_info = { 205 - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, 206 - .commandPool = vk->cmd_pool, 207 - .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 208 - .commandBufferCount = 1, 209 - }; 210 - 211 - VkCommandBuffer cmd = VK_NULL_HANDLE; 212 - 213 - os_mutex_lock(&vk->cmd_pool_mutex); 214 - 215 - ret = vk->vkAllocateCommandBuffers(vk->device, // 216 - &cmd_buffer_info, // 217 - &cmd); // 218 - 219 - os_mutex_unlock(&vk->cmd_pool_mutex); 220 - 221 - if (ret != VK_SUCCESS) { 222 - VK_ERROR(vk, "vkCreateFramebuffer failed: %s", vk_result_string(ret)); 223 - return ret; 224 - } 225 - 226 - *out_cmd = cmd; 227 - 228 - return VK_SUCCESS; 229 - } 230 - 231 - static VkResult 232 - begin_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer) 233 - { 234 - VkResult ret; 235 - 236 - VkCommandBufferBeginInfo command_buffer_info = { 237 - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, 238 - }; 239 - 240 - ret = vk->vkBeginCommandBuffer(command_buffer, &command_buffer_info); 241 - if (ret != VK_SUCCESS) { 242 - VK_ERROR(vk, "vkBeginCommandBuffer failed: %s", vk_result_string(ret)); 243 - return ret; 244 - } 245 166 246 167 return VK_SUCCESS; 247 168 } ··· 507 428 NULL); // pDescriptorCopies 508 429 } 509 430 510 - static void 511 - destroy_command_buffer(struct vk_bundle *vk, VkCommandBuffer command_buffer) 512 - { 513 - os_mutex_lock(&vk->cmd_pool_mutex); 514 - 515 - vk->vkFreeCommandBuffers( // 516 - vk->device, // device 517 - vk->cmd_pool, // commandPool 518 - 1, // commandBufferCount 519 - &command_buffer); // pCommandBuffers 520 - 521 - os_mutex_unlock(&vk->cmd_pool_mutex); 522 - } 523 - 524 431 525 432 /* 526 433 * ··· 595 502 * Per rendering. 596 503 */ 597 504 598 - C(create_command_buffer(vk, &rr->cmd)); 505 + C(vk_create_command_buffer(vk, &rr->cmd)); 599 506 600 - C(begin_command_buffer(vk, rr->cmd)); 507 + C(vk_begin_command_buffer(vk, rr->cmd)); 601 508 602 509 603 510 /* 604 511 * Mesh per view 605 512 */ 606 513 607 - C(create_descriptor_set( // 514 + C(vk_create_descriptor_set( // 608 515 vk, // vk_bundle 609 516 r->mesh.descriptor_pool, // descriptor_pool 610 517 r->mesh.descriptor_set_layout, // descriptor_set_layout 611 518 &rr->views[0].mesh.descriptor_set)); // descriptor_set 612 519 613 - C(create_descriptor_set( // 520 + C(vk_create_descriptor_set( // 614 521 vk, // vk_bundle 615 522 r->mesh.descriptor_pool, // descriptor_pool 616 523 r->mesh.descriptor_set_layout, // descriptor_set_layout ··· 623 530 comp_rendering_finalize(struct comp_rendering *rr) 624 531 { 625 532 struct vk_bundle *vk = vk_from_rr(rr); 626 - VkResult ret; 627 533 628 - // End the command buffer. 629 - ret = vk->vkEndCommandBuffer(rr->cmd); 630 - if (ret != VK_SUCCESS) { 631 - VK_ERROR(vk, "vkEndCommandBuffer failed: %s", vk_result_string(ret)); 632 - return; 633 - } 534 + vk_end_command_buffer(vk, rr->cmd); 634 535 } 635 536 636 537 void ··· 639 540 struct vk_bundle *vk = vk_from_rr(rr); 640 541 struct comp_resources *r = rr->r; 641 542 642 - destroy_command_buffer(vk, rr->cmd); 543 + vk_destroy_command_buffer(vk, rr->cmd); 643 544 rr->cmd = VK_NULL_HANDLE; 644 545 645 546 // Reclaimed by vkResetDescriptorPool.
+38 -185
src/xrt/compositor/render/comp_resources.c
··· 36 36 } 37 37 38 38 39 - static VkResult 40 - create_pipeline_cache(struct vk_bundle *vk, VkPipelineCache *out_pipeline_cache) 41 - { 42 - VkResult ret; 43 - 44 - VkPipelineCacheCreateInfo pipeline_cache_info = { 45 - .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, 46 - }; 47 - 48 - VkPipelineCache pipeline_cache; 49 - ret = vk->vkCreatePipelineCache(vk->device, // 50 - &pipeline_cache_info, // 51 - NULL, // 52 - &pipeline_cache); // 53 - if (ret != VK_SUCCESS) { 54 - VK_ERROR(vk, "vkCreatePipelineCache failed: %s", vk_result_string(ret)); 55 - return ret; 56 - } 57 - 58 - *out_pipeline_cache = pipeline_cache; 59 - 60 - return VK_SUCCESS; 61 - } 62 - 63 - static VkResult 64 - create_pipeline_layout(struct vk_bundle *vk, 65 - VkDescriptorSetLayout descriptor_set_layout, 66 - VkPipelineLayout *out_pipeline_layout) 67 - { 68 - VkResult ret; 69 - 70 - VkPipelineLayoutCreateInfo pipeline_layout_info = { 71 - .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, 72 - .setLayoutCount = 1, 73 - .pSetLayouts = &descriptor_set_layout, 74 - }; 75 - 76 - VkPipelineLayout pipeline_layout = VK_NULL_HANDLE; 77 - ret = vk->vkCreatePipelineLayout(vk->device, // 78 - &pipeline_layout_info, // 79 - NULL, // 80 - &pipeline_layout); // 81 - if (ret != VK_SUCCESS) { 82 - VK_ERROR(vk, "vkCreatePipelineLayout failed: %s", vk_result_string(ret)); 83 - return ret; 84 - } 85 - 86 - *out_pipeline_layout = pipeline_layout; 87 - 88 - return VK_SUCCESS; 89 - } 90 - 91 - static VkResult 92 - create_descriptor_pool(struct vk_bundle *vk, 93 - uint32_t num_uniform_per_desc, 94 - uint32_t num_sampler_per_desc, 95 - uint32_t num_storage_per_desc, 96 - uint32_t num_descs, 97 - bool freeable, 98 - VkDescriptorPool *out_descriptor_pool) 99 - { 100 - VkResult ret; 101 - 102 - 103 - uint32_t count = 0; 104 - VkDescriptorPoolSize pool_sizes[3] = {0}; 105 - 106 - if (num_uniform_per_desc > 0) { 107 - pool_sizes[count].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; 108 - pool_sizes[count].descriptorCount = num_uniform_per_desc * num_descs; 109 - count++; 110 - } 111 - 112 - if (num_sampler_per_desc > 0) { 113 - pool_sizes[count].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; 114 - pool_sizes[count].descriptorCount = num_sampler_per_desc * num_descs; 115 - count++; 116 - } 117 - 118 - if (num_storage_per_desc > 0) { 119 - pool_sizes[count].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; 120 - pool_sizes[count].descriptorCount = num_storage_per_desc * num_descs; 121 - count++; 122 - } 123 - 124 - assert(count > 0 && count <= ARRAY_SIZE(pool_sizes)); 125 - 126 - VkDescriptorPoolCreateFlags flags = 0; 127 - 128 - if (freeable) { 129 - flags |= VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; 130 - } 131 - 132 - VkDescriptorPoolCreateInfo descriptor_pool_info = { 133 - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 134 - .flags = flags, 135 - .maxSets = num_descs, 136 - .poolSizeCount = count, 137 - .pPoolSizes = pool_sizes, 138 - }; 139 - 140 - VkDescriptorPool descriptor_pool = VK_NULL_HANDLE; 141 - ret = vk->vkCreateDescriptorPool(vk->device, // 142 - &descriptor_pool_info, // 143 - NULL, // 144 - &descriptor_pool); // 145 - if (ret != VK_SUCCESS) { 146 - VK_ERROR(vk, "vkCreateRenderPass failed: %s", vk_result_string(ret)); 147 - return ret; 148 - } 149 - 150 - *out_descriptor_pool = descriptor_pool; 151 - 152 - return VK_SUCCESS; 153 - } 154 - 155 - 156 39 /* 157 40 * 158 41 * Mesh ··· 352 235 } 353 236 354 237 *out_descriptor_set_layout = descriptor_set_layout; 355 - 356 - return VK_SUCCESS; 357 - } 358 - 359 - static VkResult 360 - create_compute_pipeline(struct vk_bundle *vk, 361 - VkPipelineCache pipeline_cache, 362 - VkShaderModule shader, 363 - VkPipelineLayout pipeline_layout, 364 - VkPipeline *out_compute_pipeline) 365 - { 366 - VkResult ret; 367 - 368 - VkPipelineShaderStageCreateInfo shader_stage_info = { 369 - .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, 370 - .pNext = NULL, 371 - .stage = VK_SHADER_STAGE_COMPUTE_BIT, 372 - .module = shader, 373 - .pName = "main", 374 - }; 375 - 376 - VkComputePipelineCreateInfo pipeline_info = { 377 - .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, 378 - .pNext = NULL, 379 - .flags = 0, 380 - .stage = shader_stage_info, 381 - .layout = pipeline_layout, 382 - }; 383 - 384 - VkPipeline pipeline = VK_NULL_HANDLE; 385 - ret = vk->vkCreateComputePipelines( // 386 - vk->device, // 387 - pipeline_cache, // 388 - 1, // 389 - &pipeline_info, // 390 - NULL, // 391 - &pipeline); // 392 - if (ret != VK_SUCCESS) { 393 - VK_DEBUG(vk, "vkCreateComputePipelines failed: %s", vk_result_string(ret)); 394 - return ret; 395 - } 396 - 397 - *out_compute_pipeline = pipeline; 398 238 399 239 return VK_SUCCESS; 400 240 } ··· 671 511 * Shared 672 512 */ 673 513 674 - C(create_pipeline_cache(vk, &r->pipeline_cache)); 514 + C(vk_create_pipeline_cache(vk, &r->pipeline_cache)); 675 515 676 516 677 517 /* 678 518 * Mesh static. 679 519 */ 680 520 681 - C(create_descriptor_pool(vk, // vk_bundle 682 - 1, // num_uniform_per_desc 683 - 1, // num_sampler_per_desc 684 - 0, // num_storage_per_desc 685 - 16 * 2, // num_descs 686 - false, // freeable 687 - &r->mesh.descriptor_pool)); // out_descriptor_pool 521 + struct vk_descriptor_pool_info mesh_pool_info = { 522 + .uniform_per_descriptor_count = 1, 523 + .sampler_per_descriptor_count = 1, 524 + .storage_image_per_descriptor_count = 0, 525 + .storage_buffer_per_descriptor_count = 0, 526 + .descriptor_count = 16 * 2, 527 + .freeable = false, 528 + }; 688 529 689 - C(create_mesh_descriptor_set_layout(vk, // vk_bundle 690 - r->mesh.src_binding, // src_binding 691 - r->mesh.ubo_binding, // ubo_binding 692 - &r->mesh.descriptor_set_layout)); // out_mesh_descriptor_set_layout 530 + C(vk_create_descriptor_pool( // 531 + vk, // vk_bundle 532 + &mesh_pool_info, // info 533 + &r->mesh.descriptor_pool)); // out_descriptor_pool 693 534 694 - C(create_pipeline_layout(vk, // vk_bundle 695 - r->mesh.descriptor_set_layout, // descriptor_set_layout 696 - &r->mesh.pipeline_layout)); // out_pipeline_layout 535 + C(create_mesh_descriptor_set_layout( // 536 + vk, // vk_bundle 537 + r->mesh.src_binding, // src_binding 538 + r->mesh.ubo_binding, // ubo_binding 539 + &r->mesh.descriptor_set_layout)); // out_mesh_descriptor_set_layout 540 + 541 + C(vk_create_pipeline_layout( // 542 + vk, // vk_bundle 543 + r->mesh.descriptor_set_layout, // descriptor_set_layout 544 + &r->mesh.pipeline_layout)); // out_pipeline_layout 697 545 698 546 if (!init_mesh_vertex_buffers(vk, // 699 547 &r->mesh.vbo, // ··· 722 570 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // clamp_mode 723 571 &r->compute.default_sampler)); // out_sampler 724 572 725 - C(create_descriptor_pool( // 573 + struct vk_descriptor_pool_info compute_pool_info = { 574 + .uniform_per_descriptor_count = 1, 575 + .sampler_per_descriptor_count = 8, 576 + .storage_image_per_descriptor_count = 1, 577 + .storage_buffer_per_descriptor_count = 0, 578 + .descriptor_count = 1, 579 + .freeable = false, 580 + }; 581 + 582 + C(vk_create_descriptor_pool( // 726 583 vk, // vk_bundle 727 - 1, // num_uniform_per_desc 728 - 8, // num_sampler_per_desc 729 - 1, // num_storage_per_desc 730 - 1, // num_descs 731 - false, // freeable 584 + &compute_pool_info, // info 732 585 &r->compute.descriptor_pool)); // out_descriptor_pool 733 586 734 587 C(create_compute_descriptor_set_layout( // ··· 739 592 r->compute.ubo_binding, // ubo_binding, 740 593 &r->compute.descriptor_set_layout)); // out_descriptor_set_layout 741 594 742 - C(create_pipeline_layout( // 595 + C(vk_create_pipeline_layout( // 743 596 vk, // vk_bundle 744 597 r->compute.descriptor_set_layout, // descriptor_set_layout 745 598 &r->compute.pipeline_layout)); // out_pipeline_layout 746 599 747 - C(create_compute_pipeline( // 600 + C(vk_create_compute_pipeline( // 748 601 vk, // vk_bundle 749 602 r->pipeline_cache, // pipeline_cache 750 603 r->shaders->clear_comp, // shader 751 604 r->compute.pipeline_layout, // pipeline_layout 752 605 &r->compute.clear_pipeline)); // out_compute_pipeline 753 606 754 - C(create_compute_pipeline( // 607 + C(vk_create_compute_pipeline( // 755 608 vk, // vk_bundle 756 609 r->pipeline_cache, // pipeline_cache 757 610 r->shaders->distortion_comp, // shader 758 611 r->compute.pipeline_layout, // pipeline_layout 759 612 &r->compute.distortion_pipeline)); // out_compute_pipeline 760 613 761 - C(create_compute_pipeline( // 614 + C(vk_create_compute_pipeline( // 762 615 vk, // vk_bundle 763 616 r->pipeline_cache, // pipeline_cache 764 617 r->shaders->distortion_timewarp_comp, // shader