+24 -6

src/xrt/compositor/main/comp_renderer.c

reviewed

··· 101 101 int32_t fenced_buffer; 102 102 103 103 /*! 104 104 + * The render pass used to render to the target, it depends on the 105 105 + * target's format so will be recreated each time the target changes. 106 106 + */ 107 107 + struct render_gfx_render_pass target_render_pass; 108 108 + 109 109 + /*! 104 110 * Array of "rendering" target resources equal in size to the number of 105 111 * comp_target images. Each target resources holds all of the resources 106 112 * needed to render to that target and its views. ··· 212 218 213 219 struct comp_compositor *c = r->c; 214 220 215 215 - struct render_gfx_target_data data; 216 216 - data.format = r->c->target->format; 217 217 - data.is_external = true; 218 218 - data.width = r->c->target->width; 219 219 - data.height = r->c->target->height; 221 221 + VkImageView image_view = r->c->target->images[index].view; 222 222 + VkExtent2D extent = {r->c->target->width, r->c->target->height}; 220 223 221 221 - render_gfx_target_resources_init(rtr, &c->nr, r->c->target->images[index].view, &data); 224 224 + render_gfx_target_resources_init( // 225 225 + rtr, // 226 226 + &c->nr, // 227 227 + &r->target_render_pass, // 228 228 + image_view, // 229 229 + extent); // 222 230 } 223 231 224 232 /*! ··· 376 384 if (!use_compute) { 377 385 r->rtr_array = U_TYPED_ARRAY_CALLOC(struct render_gfx_target_resources, r->buffer_count); 378 386 387 387 + render_gfx_render_pass_init( // 388 388 + &r->target_render_pass, // rgrp 389 389 + &r->c->nr, // r 390 390 + r->c->target->format, // format 391 391 + VK_ATTACHMENT_LOAD_OP_CLEAR, // load_op 392 392 + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); // final_layout 393 393 + 379 394 for (uint32_t i = 0; i < r->buffer_count; ++i) { 380 395 renderer_build_rendering_target_resources(r, &r->rtr_array[i], i); 381 396 } ··· 413 428 for (uint32_t i = 0; i < r->buffer_count; i++) { 414 429 render_gfx_target_resources_close(&r->rtr_array[i]); 415 430 } 431 431 + 432 432 + // Close the render pass used for rendering to the target. 433 433 + render_gfx_render_pass_close(&r->target_render_pass); 416 434 417 435 free(r->rtr_array); 418 436 r->rtr_array = NULL;

+79 -37

src/xrt/compositor/render/render_gfx.c

reviewed

··· 424 424 425 425 /* 426 426 * 427 427 + * 'Exported' render pass functions. 428 428 + * 429 429 + */ 430 430 + 431 431 + bool 432 432 + render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp, 433 433 + struct render_resources *r, 434 434 + VkFormat format, 435 435 + VkAttachmentLoadOp load_op, 436 436 + VkImageLayout final_layout) 437 437 + { 438 438 + C(create_implicit_render_pass( // 439 439 + r->vk, // vk_bundle 440 440 + format, // target_format 441 441 + load_op, // load_op 442 442 + final_layout, // final_layout 443 443 + &rgrp->render_pass)); // out_render_pass 444 444 + 445 445 + C(create_mesh_pipeline( // 446 446 + r->vk, // vk_bundle 447 447 + rgrp->render_pass, // render_pass 448 448 + r->mesh.pipeline_layout, // pipeline_layout 449 449 + r->pipeline_cache, // pipeline_cache 450 450 + r->mesh.src_binding, // src_binding 451 451 + r->mesh.index_count_total, // mesh_index_count_total 452 452 + r->mesh.stride, // mesh_stride 453 453 + r->shaders->mesh_vert, // mesh_vert 454 454 + r->shaders->mesh_frag, // mesh_frag 455 455 + &rgrp->mesh.pipeline)); // out_mesh_pipeline 456 456 + 457 457 + // Set fields. 458 458 + rgrp->r = r; 459 459 + rgrp->format = format; 460 460 + rgrp->sample_count = VK_SAMPLE_COUNT_1_BIT; 461 461 + rgrp->load_op = load_op; 462 462 + rgrp->final_layout = final_layout; 463 463 + 464 464 + return true; 465 465 + } 466 466 + 467 467 + void 468 468 + render_gfx_render_pass_close(struct render_gfx_render_pass *rgrp) 469 469 + { 470 470 + struct vk_bundle *vk = rgrp->r->vk; 471 471 + 472 472 + D(RenderPass, rgrp->render_pass); 473 473 + D(Pipeline, rgrp->mesh.pipeline); 474 474 + 475 475 + U_ZERO(rgrp); 476 476 + } 477 477 + 478 478 + 479 479 + /* 480 480 + * 427 481 * 'Exported' target resources functions. 428 482 * 429 483 */ ··· 431 485 bool 432 486 render_gfx_target_resources_init(struct render_gfx_target_resources *rtr, 433 487 struct render_resources *r, 488 488 + struct render_gfx_render_pass *rgrp, 434 489 VkImageView target, 435 435 - struct render_gfx_target_data *data) 490 490 + VkExtent2D extent) 436 491 { 437 492 struct vk_bundle *vk = r->vk; 438 493 rtr->r = r; 439 494 440 440 - assert(data->is_external); 495 495 + C(create_framebuffer( // 496 496 + vk, // vk_bundle, 497 497 + target, // image_view, 498 498 + rgrp->render_pass, // render_pass, 499 499 + extent.width, // width, 500 500 + extent.height, // height, 501 501 + &rtr->framebuffer)); // out_external_framebuffer 441 502 442 442 - rtr->data = *data; 443 443 - 444 444 - C(create_implicit_render_pass( // 445 445 - vk, // vk_bundle 446 446 - data->format, // target_format 447 447 - VK_ATTACHMENT_LOAD_OP_CLEAR, // load_op 448 448 - VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // final_layout 449 449 - &rtr->render_pass)); // out_render_pass 450 450 - 451 451 - C(create_mesh_pipeline(vk, // vk_bundle 452 452 - rtr->render_pass, // render_pass 453 453 - r->mesh.pipeline_layout, // pipeline_layout 454 454 - r->pipeline_cache, // pipeline_cache 455 455 - r->mesh.src_binding, // src_binding 456 456 - r->mesh.index_count_total, // mesh_index_count_total 457 457 - r->mesh.stride, // mesh_stride 458 458 - r->shaders->mesh_vert, // mesh_vert 459 459 - r->shaders->mesh_frag, // mesh_frag 460 460 - &rtr->mesh.pipeline)); // out_mesh_pipeline 461 461 - 462 462 - C(create_framebuffer(vk, // vk_bundle, 463 463 - target, // image_view, 464 464 - rtr->render_pass, // render_pass, 465 465 - data->width, // width, 466 466 - data->height, // height, 467 467 - &rtr->framebuffer)); // out_external_framebuffer 503 503 + // Set fields. 504 504 + rtr->rgrp = rgrp; 505 505 + rtr->extent = extent; 468 506 469 507 return true; 470 508 } ··· 474 512 { 475 513 struct vk_bundle *vk = vk_from_rtr(rtr); 476 514 477 477 - D(RenderPass, rtr->render_pass); 478 478 - D(Pipeline, rtr->mesh.pipeline); 479 515 D(Framebuffer, rtr->framebuffer); 516 516 + 517 517 + U_ZERO(rtr); 480 518 } 481 519 482 520 ··· 591 629 592 630 assert(rr->rtr == NULL); 593 631 rr->rtr = rtr; 632 632 + 633 633 + VkRenderPass render_pass = rtr->rgrp->render_pass; 634 634 + VkFramebuffer framebuffer = rtr->framebuffer; 635 635 + VkExtent2D extent = rtr->extent; 594 636 595 637 // This is shared across both views. 596 596 - begin_render_pass(vk, // 597 597 - rr->r->cmd, // 598 598 - rr->rtr->render_pass, // 599 599 - rr->rtr->framebuffer, // 600 600 - rr->rtr->data.width, // 601 601 - rr->rtr->data.height); // 638 638 + begin_render_pass(vk, // 639 639 + rr->r->cmd, // 640 640 + render_pass, // 641 641 + framebuffer, // 642 642 + extent.width, // 643 643 + extent.height); // 602 644 603 645 return true; 604 646 } ··· 702 744 vk->vkCmdBindPipeline( // 703 745 r->cmd, // commandBuffer 704 746 VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint 705 705 - rr->rtr->mesh.pipeline); // pipeline 747 747 + rr->rtr->rgrp->mesh.pipeline); // pipeline 706 748 707 749 708 750 /*

+58 -23

src/xrt/compositor/render/render_interface.h

reviewed

··· 526 526 527 527 /* 528 528 * 529 529 - * Rendering target 529 529 + * Render pass 530 530 * 531 531 */ 532 532 533 533 /*! 534 534 - * Each rendering (@ref render_gfx) render to one or more targets 535 535 - * (@ref render_gfx_target_resources), each target can have one or more 536 536 - * views (@ref render_gfx_view), this struct holds all the data that is 537 537 - * specific to the target. 534 534 + * A render pass while not depending on a @p VkFramebuffer does depend on the 535 535 + * format of the target image(s), and other options for the render pass. These 536 536 + * are used to create a @p VkRenderPass, all @p VkFramebuffer(s) and 537 537 + * @p VkPipeline depends on the @p VkRenderPass so hang off this struct. 538 538 */ 539 539 - struct render_gfx_target_data 539 539 + struct render_gfx_render_pass 540 540 { 541 541 - // The format that should be used to read from the target. 541 541 + struct render_resources *r; 542 542 + 543 543 + //! The format of the image(s) we are rendering to. 542 544 VkFormat format; 543 545 544 544 - // Is this target a external target. 545 545 - bool is_external; 546 546 + //! Sample count for this render pass. 547 547 + VkSampleCountFlagBits sample_count; 548 548 + 549 549 + //! Load op used on the attachment(s). 550 550 + VkAttachmentLoadOp load_op; 546 551 547 547 - //! Total height and width of the target. 548 548 - uint32_t width, height; 552 552 + //! Final layout of the target image(s). 553 553 + VkImageLayout final_layout; 554 554 + 555 555 + //! Render pass used for rendering. 556 556 + VkRenderPass render_pass; 557 557 + 558 558 + struct 559 559 + { 560 560 + //! Pipeline layout used for mesh, does not depend on framebuffer. 561 561 + VkPipeline pipeline; 562 562 + } mesh; 549 563 }; 550 564 551 565 /*! 566 566 + * Creates all resources held by the render pass, does not free the struct itself. 567 567 + * 568 568 + * @public @memberof render_gfx_render_pass 569 569 + */ 570 570 + bool 571 571 + render_gfx_render_pass_init(struct render_gfx_render_pass *rgrp, 572 572 + struct render_resources *r, 573 573 + VkFormat format, 574 574 + VkAttachmentLoadOp load_op, 575 575 + VkImageLayout final_layout); 576 576 + 577 577 + /*! 578 578 + * Frees all resources held by the render pass, does not free the struct itself. 579 579 + * 580 580 + * @public @memberof render_gfx_render_pass 581 581 + */ 582 582 + void 583 583 + render_gfx_render_pass_close(struct render_gfx_render_pass *rgrp); 584 584 + 585 585 + 586 586 + /* 587 587 + * 588 588 + * Rendering target 589 589 + * 590 590 + */ 591 591 + 592 592 + /*! 552 593 * Each rendering (@ref render_gfx) render to one or more targets 553 594 * (@ref render_gfx_target_resources), each target can have one or more 554 595 * views (@ref render_gfx_view), this struct holds all the vulkan resources ··· 564 605 //! Collections of static resources. 565 606 struct render_resources *r; 566 607 567 567 - //! The data for this target. 568 568 - struct render_gfx_target_data data; 569 569 - 570 570 - //! Render pass used for rendering, does not depend on framebuffer. 571 571 - VkRenderPass render_pass; 608 608 + //! Render pass. 609 609 + struct render_gfx_render_pass *rgrp; 572 610 573 573 - struct 574 574 - { 575 575 - //! Pipeline layout used for mesh, does not depend on framebuffer. 576 576 - VkPipeline pipeline; 577 577 - } mesh; 611 611 + // The extent of the framebuffer. 612 612 + VkExtent2D extent; 578 613 579 614 //! Framebuffer for this target, depends on given VkImageView. 580 615 VkFramebuffer framebuffer; 581 616 }; 582 582 - 583 617 584 618 /*! 585 619 * Init a target resource struct, caller has to keep target alive until closed. ··· 589 623 bool 590 624 render_gfx_target_resources_init(struct render_gfx_target_resources *rtr, 591 625 struct render_resources *r, 626 626 + struct render_gfx_render_pass *rgrp, 592 627 VkImageView target, 593 593 - struct render_gfx_target_data *data); 628 628 + VkExtent2D extent); 594 629 595 630 /*! 596 631 * Frees all resources held by the target, does not free the struct itself.