+4 -1

doc/changes/compositor/mr.2323.md

reviewed

··· 1 1 - Change: Small renames in comp/render code for consistency. 1 1 + --- 2 2 + - mr.2380 3 3 + --- 4 4 + - Change: Renames in `comp/render/*` and `comp/util/comp_render_*` code for consistency.

+32 -33

src/xrt/compositor/util/comp_render_cs.c

reviewed

··· 328 328 *out_cur_image = cur_image; 329 329 } 330 330 331 331 - 332 332 - 333 333 - /* 334 334 - * 335 335 - * Compute distortion helpers. 336 336 - * 337 337 - */ 338 338 - 339 331 static void 340 340 - do_cs_clear(struct render_compute *render, const struct comp_render_dispatch_data *d) 332 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 353 + /* 354 354 + * 355 355 + * Compute distortion helpers. 356 356 + * 357 357 + */ 358 358 + 359 359 + /// For use after squashing layers 361 360 static void 362 362 - do_cs_distortion_from_scratch(struct render_compute *render, const struct comp_render_dispatch_data *d) 361 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 404 + /// Fast path 405 405 static void 406 406 - do_cs_distortion_for_layer(struct render_compute *render, 407 407 - const struct comp_render_dispatch_data *d, 408 408 - const struct comp_layer *layer, 409 409 - const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 406 406 + crc_distortion_fast_path(struct render_compute *render, 407 407 + const struct comp_render_dispatch_data *d, 408 408 + const struct comp_layer *layer, 409 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 493 - * 'Exported' compute helpers. 493 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 710 - transition_to, // transition_to 710 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 740 - do_cs_distortion_for_layer( // 741 741 - render, // 742 742 - d, // 743 743 - layer, // 744 744 - vds); // 740 740 + crc_distortion_fast_path( // 741 741 + render, // 742 742 + d, // 743 743 + layer, // 744 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 753 - do_cs_distortion_for_layer( // 754 754 - render, // 755 755 - d, // 756 756 - layer, // 757 757 - vds); // 753 753 + crc_distortion_fast_path( // 754 754 + render, // 755 755 + d, // 756 756 + layer, // 757 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 764 - 765 764 766 765 /* 767 766 * Layer squashing. ··· 776 775 /* 777 776 * Distortion. 778 777 */ 778 778 + crc_distortion_after_squash( // 779 779 + render, // 780 780 + d); // 779 781 780 780 - do_cs_distortion_from_scratch( // 781 781 - render, // 782 782 - d); // 783 782 } else { 784 783 // Just clear the screen 785 785 - do_cs_clear( // 786 786 - render, // 787 787 - d); // 784 784 + crc_clear_output( // 785 785 + render, // 786 786 + d); // 788 787 } 789 788 }

+232 -208

src/xrt/compositor/util/comp_render_gfx.c

reviewed

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