The open source OpenXR runtime
0
fork

Configure Feed

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

c/util: more renames and re-orgs to align compute and gfx

Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2380>

+268 -242
+4 -1
doc/changes/compositor/mr.2323.md
··· 1 - Change: Small renames in comp/render code for consistency. 1 + --- 2 + - mr.2380 3 + --- 4 + - Change: Renames in `comp/render/*` and `comp/util/comp_render_*` code for consistency.
+32 -33
src/xrt/compositor/util/comp_render_cs.c
··· 328 328 *out_cur_image = cur_image; 329 329 } 330 330 331 - 332 - 333 - /* 334 - * 335 - * Compute distortion helpers. 336 - * 337 - */ 338 - 339 331 static void 340 - do_cs_clear(struct render_compute *render, const struct comp_render_dispatch_data *d) 332 + crc_clear_output(struct render_compute *render, const struct comp_render_dispatch_data *d) 341 333 { 342 334 if (d->view_count > XRT_MAX_VIEWS) { 343 335 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); ··· 358 350 target_viewport_datas); // views 359 351 } 360 352 353 + /* 354 + * 355 + * Compute distortion helpers. 356 + * 357 + */ 358 + 359 + /// For use after squashing layers 361 360 static void 362 - do_cs_distortion_from_scratch(struct render_compute *render, const struct comp_render_dispatch_data *d) 361 + crc_distortion_after_squash(struct render_compute *render, const struct comp_render_dispatch_data *d) 363 362 { 364 363 if (d->view_count > XRT_MAX_VIEWS) { 365 364 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); ··· 402 401 target_viewport_datas); // views 403 402 } 404 403 404 + /// Fast path 405 405 static void 406 - do_cs_distortion_for_layer(struct render_compute *render, 407 - const struct comp_render_dispatch_data *d, 408 - const struct comp_layer *layer, 409 - const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 406 + crc_distortion_fast_path(struct render_compute *render, 407 + const struct comp_render_dispatch_data *d, 408 + const struct comp_layer *layer, 409 + const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 410 410 { 411 411 if (d->view_count > XRT_MAX_VIEWS) { 412 412 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); ··· 490 490 491 491 /* 492 492 * 493 - * 'Exported' compute helpers. 493 + * 'Exported' function(s). 494 494 * 495 495 */ 496 496 ··· 707 707 VK_ACCESS_SHADER_WRITE_BIT, // src_access_mask 708 708 VK_ACCESS_MEMORY_READ_BIT, // dst_access_mask 709 709 VK_IMAGE_LAYOUT_GENERAL, // transition_from 710 - transition_to, // transition_to 710 + transition_to, // 711 711 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, // src_stage_mask 712 712 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); // dst_stage_mask 713 713 } ··· 737 737 for (uint32_t view = 0; view < d->view_count; ++view) { 738 738 vds[view] = &proj->v[view]; 739 739 } 740 - do_cs_distortion_for_layer( // 741 - render, // 742 - d, // 743 - layer, // 744 - vds); // 740 + crc_distortion_fast_path( // 741 + render, // 742 + d, // 743 + layer, // 744 + vds); // 745 745 746 746 } else if (fast_path && layer->data.type == XRT_LAYER_PROJECTION_DEPTH) { 747 747 // Fast path. ··· 750 750 for (uint32_t view = 0; view < d->view_count; ++view) { 751 751 vds[view] = &depth->v[view]; 752 752 } 753 - do_cs_distortion_for_layer( // 754 - render, // 755 - d, // 756 - layer, // 757 - vds); // 753 + crc_distortion_fast_path( // 754 + render, // 755 + d, // 756 + layer, // 757 + vds); // 758 758 759 759 } else if (layer_count > 0) { 760 760 // Compute layer squasher 761 761 if (fast_path) { 762 762 U_LOG_W("Wanted fast path but no projection layer, falling back to layer squasher."); 763 763 } 764 - 765 764 766 765 /* 767 766 * Layer squashing. ··· 776 775 /* 777 776 * Distortion. 778 777 */ 778 + crc_distortion_after_squash( // 779 + render, // 780 + d); // 779 781 780 - do_cs_distortion_from_scratch( // 781 - render, // 782 - d); // 783 782 } else { 784 783 // Just clear the screen 785 - do_cs_clear( // 786 - render, // 787 - d); // 784 + crc_clear_output( // 785 + render, // 786 + d); // 788 787 } 789 788 }
+232 -208
src/xrt/compositor/util/comp_render_gfx.c
··· 485 485 } 486 486 487 487 static void 488 - do_layers(struct render_gfx *render, 489 - const struct comp_layer *layers, 490 - uint32_t layer_count, 491 - const struct comp_render_dispatch_data *d) 488 + crg_clear_output(struct render_gfx *render, const struct comp_render_dispatch_data *d) 489 + { 490 + render_gfx_begin_target( // 491 + render, // 492 + d->gfx.rtr, // 493 + &background_color_idle); // 494 + 495 + render_gfx_end_target(render); 496 + } 497 + 498 + /* 499 + * 500 + * Graphics distortion helpers. 501 + * 502 + */ 503 + 504 + /// Used in both fast-path and layer-squashed routes 505 + static void 506 + crg_distortion_common(struct render_gfx *render, 507 + bool do_timewarp, 508 + const struct gfx_mesh_data *md, 509 + const struct comp_render_dispatch_data *d) 510 + { 511 + struct vk_bundle *vk = render->r->vk; 512 + VkResult ret; 513 + 514 + /* 515 + * Reserve UBOs, create descriptor sets, and fill in any data ahead of 516 + * time. If we ever want to copy UBO data this lets us do that easily: 517 + * write a copy command before the other gfx commands. 518 + */ 519 + 520 + struct gfx_mesh_state ms = XRT_STRUCT_INIT; 521 + 522 + for (uint32_t i = 0; i < d->view_count; i++) { 523 + 524 + struct render_gfx_mesh_ubo_data data = { 525 + .vertex_rot = d->views[i].gfx.vertex_rot, 526 + .post_transform = md->views[i].src_norm_rect, 527 + }; 528 + 529 + // Extra arguments for timewarp. 530 + if (do_timewarp) { 531 + data.pre_transform = d->views[i].target_pre_transform; 532 + 533 + render_calc_time_warp_matrix( // 534 + &md->views[i].src_pose, // 535 + &md->views[i].src_fov, // 536 + &d->views[i].world_pose, // 537 + &data.transform); // 538 + } 539 + 540 + ret = render_gfx_mesh_alloc_and_write( // 541 + render, // 542 + &data, // 543 + md->views[i].src_sampler, // 544 + md->views[i].src_image_view, // 545 + &ms.descriptor_sets[i]); // 546 + VK_CHK_WITH_GOTO(ret, "render_gfx_mesh_alloc", err_no_memory); 547 + 548 + VK_NAME_DESCRIPTOR_SET(vk, ms.descriptor_sets[i], "render_gfx mesh descriptor sets"); 549 + } 550 + 551 + 552 + /* 553 + * Do command writing here. 554 + */ 555 + 556 + render_gfx_begin_target( // 557 + render, // 558 + d->gfx.rtr, // 559 + &background_color_active); // 560 + 561 + for (uint32_t i = 0; i < d->view_count; i++) { 562 + // Convenience. 563 + const struct render_viewport_data *viewport_data = &d->views[i].target_viewport_data; 564 + 565 + render_gfx_begin_view( // 566 + render, // 567 + i, // view_index 568 + viewport_data); // 569 + 570 + render_gfx_mesh_draw( // 571 + render, // 572 + i, // mesh_index 573 + ms.descriptor_sets[i], // 574 + do_timewarp); // 575 + 576 + render_gfx_end_view(render); 577 + } 578 + 579 + render_gfx_end_target(render); 580 + 581 + return; 582 + 583 + err_no_memory: 584 + // Allocator reset at end of frame, nothing to clean up. 585 + VK_ERROR(vk, "Could not allocate all UBOs for frame, that's really strange and shouldn't happen!"); 586 + } 587 + 588 + /// For use after squashing layers 589 + static void 590 + crg_distortion_after_squash(struct render_gfx *render, const struct comp_render_dispatch_data *d) 591 + { 592 + 593 + // Shared between all views. 594 + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 595 + 596 + struct gfx_mesh_data md = XRT_STRUCT_INIT; 597 + for (uint32_t i = 0; i < d->view_count; i++) { 598 + struct xrt_pose src_pose = d->views[i].world_pose; 599 + struct xrt_fov src_fov = d->views[i].fov; 600 + VkImageView src_image_view = d->views[i].srgb_view; 601 + struct xrt_normalized_rect src_norm_rect = d->views[i].layer_norm_rect; 602 + 603 + gfx_mesh_add_view( // 604 + &md, // 605 + i, // view_index 606 + &src_pose, // 607 + &src_fov, // 608 + &src_norm_rect, // 609 + clamp_to_border_black, // src_sampler 610 + src_image_view); // 611 + } 612 + 613 + // We are passing in the same old and new poses. 614 + crg_distortion_common( // 615 + render, // 616 + false, // do_timewarp 617 + &md, // 618 + d); // 619 + } 620 + 621 + /// Fast path 622 + static void 623 + crg_distortion_fast_path(struct render_gfx *render, 624 + const struct comp_render_dispatch_data *d, 625 + const struct comp_layer *layer, 626 + const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 627 + { 628 + const struct xrt_layer_data *data = &layer->data; 629 + 630 + const VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 631 + 632 + struct gfx_mesh_data md = XRT_STRUCT_INIT; 633 + for (uint32_t i = 0; i < d->view_count; i++) { 634 + const uint32_t array_index = vds[i]->sub.array_index; 635 + 636 + const struct comp_swapchain_image *image = get_layer_image(layer, i, vds[i]->sub.image_index); 637 + 638 + struct xrt_pose src_pose; 639 + struct xrt_fov src_fov; 640 + struct xrt_normalized_rect src_norm_rect; 641 + 642 + src_pose = vds[i]->pose; 643 + src_fov = vds[i]->fov; 644 + src_norm_rect = vds[i]->sub.norm_rect; 645 + const VkImageView src_image_view = get_image_view(image, data->flags, array_index); 646 + 647 + if (data->flip_y) { 648 + src_norm_rect.y += src_norm_rect.h; 649 + src_norm_rect.h = -src_norm_rect.h; 650 + } 651 + 652 + gfx_mesh_add_view( // 653 + &md, // md 654 + i, // view_index 655 + &src_pose, // src_pose 656 + &src_fov, // src_fov 657 + &src_norm_rect, // src_norm_rect 658 + clamp_to_border_black, // src_sampler 659 + src_image_view); // src_image_view 660 + } 661 + 662 + crg_distortion_common( // 663 + render, // 664 + d->do_timewarp, // 665 + &md, // 666 + d); // 667 + } 668 + 669 + 670 + /* 671 + * 672 + * 'Exported' function(s). 673 + * 674 + */ 675 + 676 + void 677 + comp_render_gfx_layers(struct render_gfx *render, 678 + const struct comp_layer *layers, 679 + uint32_t layer_count, 680 + const struct comp_render_dispatch_data *d, 681 + VkImageLayout transition_to) 492 682 { 493 683 COMP_TRACE_MARKER(); 494 684 ··· 669 859 } 670 860 671 861 672 - return; 673 - 674 - err_layer: 675 - // Allocator reset at end of frame, nothing to clean up. 676 - VK_ERROR(vk, "Layer processing failed, that shouldn't happen!"); 677 - } 678 - 679 - 680 - /* 681 - * 682 - * Graphics distortion helpers. 683 - * 684 - */ 685 - 686 - static void 687 - do_mesh(struct render_gfx *render, 688 - bool do_timewarp, 689 - const struct gfx_mesh_data *md, 690 - const struct comp_render_dispatch_data *d) 691 - { 692 - struct vk_bundle *vk = render->r->vk; 693 - VkResult ret; 694 - 695 - /* 696 - * Reserve UBOs, create descriptor sets, and fill in any data ahead of 697 - * time. If we ever want to copy UBO data this lets us do that easily: 698 - * write a copy command before the other gfx commands. 699 - */ 700 - 701 - struct gfx_mesh_state ms = XRT_STRUCT_INIT; 702 - 703 - for (uint32_t i = 0; i < d->view_count; i++) { 704 - 705 - struct render_gfx_mesh_ubo_data data = { 706 - .vertex_rot = d->views[i].gfx.vertex_rot, 707 - .post_transform = md->views[i].src_norm_rect, 708 - }; 709 - 710 - // Extra arguments for timewarp. 711 - if (do_timewarp) { 712 - data.pre_transform = d->views[i].target_pre_transform; 713 - 714 - render_calc_time_warp_matrix( // 715 - &md->views[i].src_pose, // 716 - &md->views[i].src_fov, // 717 - &d->views[i].world_pose, // 718 - &data.transform); // 719 - } 720 - 721 - ret = render_gfx_mesh_alloc_and_write( // 722 - render, // 723 - &data, // 724 - md->views[i].src_sampler, // 725 - md->views[i].src_image_view, // 726 - &ms.descriptor_sets[i]); // 727 - VK_CHK_WITH_GOTO(ret, "render_gfx_mesh_alloc", err_no_memory); 728 - 729 - VK_NAME_DESCRIPTOR_SET(vk, ms.descriptor_sets[i], "render_gfx mesh descriptor sets"); 730 - } 731 - 732 - 733 - /* 734 - * Do command writing here. 735 - */ 736 - 737 - render_gfx_begin_target( // 738 - render, // 739 - d->gfx.rtr, // 740 - &background_color_active); // 741 - 742 - for (uint32_t i = 0; i < d->view_count; i++) { 743 - // Convenience. 744 - const struct render_viewport_data *viewport_data = &d->views[i].target_viewport_data; 745 - 746 - render_gfx_begin_view( // 747 - render, // 748 - i, // view_index 749 - viewport_data); // 750 - 751 - render_gfx_mesh_draw( // 752 - render, // 753 - i, // mesh_index 754 - ms.descriptor_sets[i], // 755 - do_timewarp); // 862 + VkImageLayout transition_from = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; 756 863 757 - render_gfx_end_view(render); 758 - } 759 - 760 - render_gfx_end_target(render); 864 + cmd_barrier_view_images( // 865 + render->r->vk, // 866 + d, // 867 + render->r->cmd, // cmd 868 + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // src_access_mask 869 + VK_ACCESS_SHADER_READ_BIT, // dst_access_mask 870 + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // transition_from 871 + transition_to, // 872 + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // src_stage_mask 873 + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); // dst_stage_mask 761 874 762 875 return; 763 876 764 - err_no_memory: 877 + err_layer: 765 878 // Allocator reset at end of frame, nothing to clean up. 766 - VK_ERROR(vk, "Could not allocate all UBOs for frame, that's really strange and shouldn't happen!"); 767 - } 768 - 769 - static void 770 - do_mesh_from_proj(struct render_gfx *render, 771 - const struct comp_render_dispatch_data *d, 772 - const struct comp_layer *layer, 773 - const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 774 - { 775 - const struct xrt_layer_data *data = &layer->data; 776 - 777 - const VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 778 - 779 - struct gfx_mesh_data md = XRT_STRUCT_INIT; 780 - for (uint32_t i = 0; i < d->view_count; i++) { 781 - const uint32_t array_index = vds[i]->sub.array_index; 782 - 783 - const struct comp_swapchain_image *image = get_layer_image(layer, i, vds[i]->sub.image_index); 784 - 785 - struct xrt_pose src_pose; 786 - struct xrt_fov src_fov; 787 - struct xrt_normalized_rect src_norm_rect; 788 - 789 - src_pose = vds[i]->pose; 790 - src_fov = vds[i]->fov; 791 - src_norm_rect = vds[i]->sub.norm_rect; 792 - const VkImageView src_image_view = get_image_view(image, data->flags, array_index); 793 - 794 - if (data->flip_y) { 795 - src_norm_rect.y += src_norm_rect.h; 796 - src_norm_rect.h = -src_norm_rect.h; 797 - } 798 - 799 - gfx_mesh_add_view( // 800 - &md, // md 801 - i, // view_index 802 - &src_pose, // src_pose 803 - &src_fov, // src_fov 804 - &src_norm_rect, // src_norm_rect 805 - clamp_to_border_black, // src_sampler 806 - src_image_view); // src_image_view 807 - } 808 - 809 - do_mesh( // 810 - render, // 811 - d->do_timewarp, // 812 - &md, // 813 - d); // 879 + VK_ERROR(vk, "Layer processing failed, that shouldn't happen!"); 814 880 } 815 881 816 882 817 - /* 818 - * 819 - * 'Exported' function(s). 820 - * 821 - */ 822 883 823 884 void 824 885 comp_render_gfx_dispatch(struct render_gfx *render, ··· 835 896 // Consistency check. 836 897 assert(!fast_path || layer_count >= 1); 837 898 899 + // We want to read from the images afterwards. 900 + VkImageLayout transition_to = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; 901 + 838 902 if (fast_path && layer->data.type == XRT_LAYER_PROJECTION) { 839 903 // Fast path. 840 904 const struct xrt_layer_projection_data *proj = &layer->data.proj; ··· 842 906 for (uint32_t view = 0; view < d->view_count; ++view) { 843 907 vds[view] = &proj->v[view]; 844 908 } 845 - do_mesh_from_proj( // 846 - render, // 847 - d, // 848 - layer, // 849 - vds); // 909 + crg_distortion_fast_path( // 910 + render, // 911 + d, // 912 + layer, // 913 + vds); // 850 914 851 915 } else if (fast_path && layer->data.type == XRT_LAYER_PROJECTION_DEPTH) { 852 916 // Fast path. ··· 855 919 for (uint32_t view = 0; view < d->view_count; ++view) { 856 920 vds[view] = &depth->v[view]; 857 921 } 858 - do_mesh_from_proj( // 859 - render, // 860 - d, // 861 - layer, // 862 - vds); // 922 + crg_distortion_fast_path( // 923 + render, // 924 + d, // 925 + layer, // 926 + vds); // 863 927 864 928 } else if (layer_count > 0) { 865 929 // Graphics layer squasher ··· 867 931 U_LOG_W("Wanted fast path but no projection layer, falling back to layer squasher."); 868 932 } 869 933 870 - 871 934 /* 872 935 * Layer squashing. 873 936 */ 874 - do_layers( // 875 - render, // 876 - layers, // 877 - layer_count, // 878 - d); // 937 + comp_render_gfx_layers( // 938 + render, // 939 + layers, // 940 + layer_count, // 941 + d, // 942 + transition_to); // 879 943 880 944 /* 881 945 * Distortion. 882 946 */ 883 - 884 - VkImageLayout transition_from = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; 885 - VkImageLayout transition_to = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; 886 - 887 - cmd_barrier_view_images( // 888 - render->r->vk, // 889 - d, // 890 - render->r->cmd, // cmd 891 - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // src_access_mask 892 - VK_ACCESS_SHADER_READ_BIT, // dst_access_mask 893 - transition_from, // 894 - transition_to, // 895 - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // src_stage_mask 896 - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); // dst_stage_mask 897 - 898 - // Shared between all views. 899 - VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 947 + crg_distortion_after_squash( // 948 + render, // 949 + d); 900 950 901 - struct gfx_mesh_data md = XRT_STRUCT_INIT; 902 - for (uint32_t i = 0; i < d->view_count; i++) { 903 - struct xrt_pose src_pose = d->views[i].world_pose; 904 - struct xrt_fov src_fov = d->views[i].fov; 905 - VkImageView src_image_view = d->views[i].srgb_view; 906 - struct xrt_normalized_rect src_norm_rect = d->views[i].layer_norm_rect; 907 - 908 - gfx_mesh_add_view( // 909 - &md, // 910 - i, // view_index 911 - &src_pose, // 912 - &src_fov, // 913 - &src_norm_rect, // 914 - clamp_to_border_black, // src_sampler 915 - src_image_view); // 916 - } 917 - 918 - // We are passing in the same old and new poses. 919 - do_mesh( // 920 - render, // 921 - false, // do_timewarp 922 - &md, // 923 - d); // 924 951 } else { 925 952 // Just clear the screen 926 - render_gfx_begin_target( // 927 - render, // 928 - d->gfx.rtr, // 929 - &background_color_idle); // 930 - 931 - render_gfx_end_target(render); 953 + crg_clear_output( // 954 + render, // 955 + d); // 932 956 } 933 957 }