c/util: More diff reduction between comp_render_{cs,gfx}

+9 -9

src/xrt/compositor/util/comp_render.h

··· 345 345 * @note Swapchains in the @p layers must implement @ref comp_swapchain in 346 346 * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! 347 347 * 348 - * @param rr GFX render object 348 + * @param render GFX render object 349 349 * @param[in] layers Layers to render, see note. 350 350 * @param[in] layer_count Number of elements in @p layers array. 351 351 * @param[in] d Common render dispatch data 352 352 */ 353 353 void 354 - comp_render_gfx_dispatch(struct render_gfx *rr, 354 + comp_render_gfx_dispatch(struct render_gfx *render, 355 355 const struct comp_layer *layers, 356 356 const uint32_t layer_count, 357 357 const struct comp_render_dispatch_data *d); ··· 468 468 * @note Swapchains in the @p layers must implement @ref comp_swapchain in 469 469 * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! 470 470 * 471 - * @param crc Compute renderer object 471 + * @param render Compute renderer object 472 472 * @param view_index Index of the view 473 473 * @param layers Layers to render, see note. 474 474 * @param layer_count Number of elements in @p layers array. ··· 481 481 * @param do_timewarp 482 482 */ 483 483 void 484 - comp_render_cs_layer(struct render_compute *crc, 484 + comp_render_cs_layer(struct render_compute *render, 485 485 uint32_t view_index, 486 486 const struct comp_layer *layers, 487 487 const uint32_t layer_count, ··· 513 513 * @note Swapchains in the @p layers must implement @ref comp_swapchain in 514 514 * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! 515 515 * 516 - * @param crc Compute renderer object 516 + * @param render Compute renderer object 517 517 * @param[in] layers Layers to render, see note. 518 518 * @param[in] layer_count Number of elements in @p layers array. 519 519 * @param[in] d Common render dispatch data 520 520 * @param[in] transition_to Desired image layout for target images 521 521 */ 522 522 void 523 - comp_render_cs_layers(struct render_compute *crc, 523 + comp_render_cs_layers(struct render_compute *render, 524 524 const struct comp_layer *layers, 525 525 const uint32_t layer_count, 526 526 const struct comp_render_dispatch_data *d, 527 527 VkImageLayout transition_to); 528 528 529 529 /*! 530 - * Write commands to @p crc to do a full composition with distortion. 530 + * Write commands to @p render to do a full composition with distortion. 531 531 * 532 532 * Helper function that takes a set of layers, new device poses, a scratch 533 533 * images and writes the needed commands to the @ref render_compute to do a full ··· 551 551 * @note Swapchains in the @p layers must implement @ref comp_swapchain in 552 552 * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! 553 553 * 554 - * @param crc Compute renderer object 554 + * @param render Compute renderer object 555 555 * @param[in] layers Layers to render, see note. 556 556 * @param[in] layer_count Number of elements in @p layers array. 557 557 * @param[in] d Common render dispatch data 558 558 * 559 559 */ 560 560 void 561 - comp_render_cs_dispatch(struct render_compute *crc, 561 + comp_render_cs_dispatch(struct render_compute *render, 562 562 const struct comp_layer *layers, 563 563 const uint32_t layer_count, 564 564 const struct comp_render_dispatch_data *d);

+72 -48

src/xrt/compositor/util/comp_render_cs.c

··· 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 - * @brief Compositor rendering code. 5 + * @brief Compositor (compute shader) rendering code. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 * @author Christoph Haag <christoph.haag@collabora.com> 8 8 * @author Fernando Velazquez Innella <finnella@magicleap.com> ··· 53 53 return &sc->images[image_index]; 54 54 } 55 55 56 + /// Data setup for a cylinder layer 56 57 static inline void 57 58 do_cs_cylinder_layer(const struct comp_layer *layer, 58 59 const struct xrt_matrix_4x4 *eye_view_mat, ··· 117 118 *out_cur_image = cur_image; 118 119 } 119 120 121 + /// Data setup for an "equirect2" layer 120 122 static inline void 121 123 do_cs_equirect2_layer(const struct comp_layer *layer, 122 124 const struct xrt_matrix_4x4 *eye_view_mat, ··· 179 181 *out_cur_image = cur_image; 180 182 } 181 183 184 + /// Data setup for a projection layer 182 185 static inline void 183 186 do_cs_projection_layer(const struct comp_layer *layer, 184 187 const struct xrt_pose *world_pose, ··· 241 244 *out_cur_image = cur_image; 242 245 } 243 246 247 + /// Data setup for a quad layer 244 248 static inline void 245 249 do_cs_quad_layer(const struct comp_layer *layer, 246 250 const struct xrt_matrix_4x4 *eye_view_mat, ··· 266 270 267 271 // Set the normalized post transform values. 268 272 struct xrt_normalized_rect post_transform = XRT_STRUCT_INIT; 273 + 274 + // Used for Subimage and OpenGL flip. 269 275 set_post_transform_rect( // 270 276 layer_data, // data 271 277 &q->sub.norm_rect, // src_norm_rect ··· 331 337 */ 332 338 333 339 static void 334 - do_cs_clear(struct render_compute *crc, const struct comp_render_dispatch_data *d) 340 + do_cs_clear(struct render_compute *render, const struct comp_render_dispatch_data *d) 335 341 { 336 342 if (d->view_count > XRT_MAX_VIEWS) { 337 343 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); ··· 346 352 347 353 348 354 render_compute_clear( // 349 - crc, // crc 355 + render, // crc 350 356 d->cs.target_image, // target_image 351 357 d->cs.target_unorm_view, // target_image_view 352 358 target_viewport_datas); // views 353 359 } 354 360 355 361 static void 356 - do_cs_distortion_from_scratch(struct render_compute *crc, const struct comp_render_dispatch_data *d) 362 + do_cs_distortion_from_scratch(struct render_compute *render, const struct comp_render_dispatch_data *d) 357 363 { 358 364 if (d->view_count > XRT_MAX_VIEWS) { 359 365 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); 360 366 assert(d->view_count < XRT_MAX_VIEWS); 361 367 return; 362 368 } 363 - VkSampler clamp_to_border_black = crc->r->samplers.clamp_to_border_black; 369 + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 364 370 365 371 // Data to fill in. 366 372 VkImageView src_image_views[XRT_MAX_VIEWS]; ··· 387 393 } 388 394 389 395 render_compute_projection( // 390 - crc, // crc 396 + render, // crc 391 397 src_samplers, // src_samplers 392 398 src_image_views, // src_image_views 393 399 src_norm_rects, // src_rects ··· 397 403 } 398 404 399 405 static void 400 - do_cs_distortion_for_layer(struct render_compute *crc, 406 + do_cs_distortion_for_layer(struct render_compute *render, 407 + const struct comp_render_dispatch_data *d, 401 408 const struct comp_layer *layer, 402 - const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS], 403 - const struct comp_render_dispatch_data *d) 409 + const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 404 410 { 405 411 if (d->view_count > XRT_MAX_VIEWS) { 406 412 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); ··· 411 417 // Fetch from this data. 412 418 const struct xrt_layer_data *data = &layer->data; 413 419 414 - VkSampler clamp_to_border_black = crc->r->samplers.clamp_to_border_black; 420 + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 415 421 416 422 // Data to fill in. 417 423 VkImageView src_image_views[XRT_MAX_VIEWS]; ··· 459 465 460 466 if (!d->do_timewarp) { 461 467 render_compute_projection( // 462 - crc, // 468 + render, // 463 469 src_samplers, // 464 470 src_image_views, // 465 471 src_norm_rects, // ··· 468 474 target_viewport_datas); // 469 475 } else { 470 476 render_compute_projection_timewarp( // 471 - crc, // 477 + render, // 472 478 src_samplers, // 473 479 src_image_views, // 474 480 src_norm_rects, // ··· 489 495 */ 490 496 491 497 void 492 - comp_render_cs_layer(struct render_compute *crc, 498 + comp_render_cs_layer(struct render_compute *render, 493 499 uint32_t view_index, 494 500 const struct comp_layer *layers, 495 501 const uint32_t layer_count, ··· 501 507 const struct render_viewport_data *target_view, 502 508 bool do_timewarp) 503 509 { 504 - VkSampler clamp_to_edge = crc->r->samplers.clamp_to_edge; 505 - VkSampler clamp_to_border_black = crc->r->samplers.clamp_to_border_black; 510 + VkSampler clamp_to_edge = render->r->samplers.clamp_to_edge; 511 + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 506 512 507 513 // Not the transform of the views, but the inverse: actual view matrices. 508 514 struct xrt_matrix_4x4 world_view_mat, eye_view_mat; 509 515 math_matrix_4x4_view_from_pose(world_pose, &world_view_mat); 510 516 math_matrix_4x4_view_from_pose(eye_pose, &eye_view_mat); 511 517 512 - struct render_buffer *ubo = &crc->r->compute.layer.ubos[view_index]; 518 + struct render_buffer *ubo = &render->r->compute.layer.ubos[view_index]; 513 519 struct render_compute_layer_ubo_data *ubo_data = ubo->mapped; 514 520 515 521 // Tightly pack layers in data struct. ··· 546 552 case XRT_LAYER_PROJECTION_DEPTH: required_image_samplers = 2; break; 547 553 case XRT_LAYER_QUAD: required_image_samplers = 1; break; 548 554 default: 549 - VK_ERROR(crc->r->vk, "Skipping layer #%u, unknown type: %u", c_layer_i, data->type); 555 + VK_ERROR(render->r->vk, "Skipping layer #%u, unknown type: %u", c_layer_i, data->type); 550 556 continue; // Skip this layer if don't know about it. 551 557 } 552 558 553 559 //! Exit loop if shader cannot receive more image samplers 554 - if (cur_image + required_image_samplers > crc->r->compute.layer.image_array_size) { 560 + if (cur_image + required_image_samplers > render->r->compute.layer.image_array_size) { 555 561 break; 556 562 } 557 563 ··· 620 626 default: 621 627 // Should not get here! 622 628 assert(false); 623 - VK_ERROR(crc->r->vk, "Should not get here!"); 629 + VK_ERROR(render->r->vk, "Should not get here!"); 624 630 continue; 625 631 } 626 632 ··· 639 645 } 640 646 641 647 //! @todo: If Vulkan 1.2, use VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT and skip this 642 - while (cur_image < crc->r->compute.layer.image_array_size) { 648 + while (cur_image < render->r->compute.layer.image_array_size) { 643 649 src_samplers[cur_image] = clamp_to_edge; 644 - src_image_views[cur_image] = crc->r->mock.color.image_view; 650 + src_image_views[cur_image] = render->r->mock.color.image_view; 645 651 cur_image++; 646 652 } 647 653 648 - VkDescriptorSet descriptor_set = crc->layer_descriptor_sets[view_index]; 654 + VkDescriptorSet descriptor_set = render->layer_descriptor_sets[view_index]; 649 655 650 656 render_compute_layers( // 651 - crc, // 657 + render, // 652 658 descriptor_set, // 653 659 ubo->buffer, // 654 660 src_samplers, // ··· 660 666 } 661 667 662 668 void 663 - comp_render_cs_layers(struct render_compute *crc, 669 + comp_render_cs_layers(struct render_compute *render, 664 670 const struct comp_layer *layers, 665 671 const uint32_t layer_count, 666 672 const struct comp_render_dispatch_data *d, 667 673 VkImageLayout transition_to) 668 674 { 669 675 cmd_barrier_view_images( // 670 - crc->r->vk, // 676 + render->r->vk, // 671 677 d, // 672 - crc->r->cmd, // cmd 678 + render->r->cmd, // cmd 673 679 0, // src_access_mask 674 680 VK_ACCESS_SHADER_WRITE_BIT, // dst_access_mask 675 681 VK_IMAGE_LAYOUT_UNDEFINED, // transition_from ··· 681 687 const struct comp_render_view_data *view = &d->views[view_index]; 682 688 683 689 comp_render_cs_layer( // 684 - crc, // 690 + render, // 685 691 view_index, // 686 692 layers, // 687 693 layer_count, // ··· 695 701 } 696 702 697 703 cmd_barrier_view_images( // 698 - crc->r->vk, // 704 + render->r->vk, // 699 705 d, // 700 - crc->r->cmd, // cmd 706 + render->r->cmd, // cmd 701 707 VK_ACCESS_SHADER_WRITE_BIT, // src_access_mask 702 708 VK_ACCESS_MEMORY_READ_BIT, // dst_access_mask 703 709 VK_IMAGE_LAYOUT_GENERAL, // transition_from ··· 707 713 } 708 714 709 715 void 710 - comp_render_cs_dispatch(struct render_compute *crc, 716 + comp_render_cs_dispatch(struct render_compute *render, 711 717 const struct comp_layer *layers, 712 718 const uint32_t layer_count, 713 719 const struct comp_render_dispatch_data *d) ··· 715 721 // Convenience. 716 722 bool fast_path = d->fast_path; 717 723 718 - assert(!fast_path || layer_count > 0); 724 + // Only used if fast_path is true. 725 + const struct comp_layer *layer = &layers[0]; 726 + 727 + // Consistency check. 728 + assert(!fast_path || layer_count >= 1); 719 729 720 730 // We want to read from the images afterwards. 721 731 VkImageLayout transition_to = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; 722 732 723 - if (fast_path && layers[0].data.type == XRT_LAYER_PROJECTION) { 724 - int i = 0; 725 - const struct comp_layer *layer = &layers[i]; 733 + if (fast_path && layer->data.type == XRT_LAYER_PROJECTION) { 734 + // Fast path. 726 735 const struct xrt_layer_projection_data *proj = &layer->data.proj; 727 736 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 728 737 for (uint32_t view = 0; view < d->view_count; ++view) { 729 738 vds[view] = &proj->v[view]; 730 739 } 731 740 do_cs_distortion_for_layer( // 732 - crc, // crc 733 - layer, // layer 734 - vds, // vds 735 - d); // d 736 - } else if (fast_path && layers[0].data.type == XRT_LAYER_PROJECTION_DEPTH) { 737 - int i = 0; 738 - const struct comp_layer *layer = &layers[i]; 741 + render, // 742 + d, // 743 + layer, // 744 + vds); // 745 + 746 + } else if (fast_path && layer->data.type == XRT_LAYER_PROJECTION_DEPTH) { 747 + // Fast path. 739 748 const struct xrt_layer_projection_depth_data *depth = &layer->data.depth; 740 749 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 741 750 for (uint32_t view = 0; view < d->view_count; ++view) { 742 751 vds[view] = &depth->v[view]; 743 752 } 744 753 do_cs_distortion_for_layer( // 745 - crc, // crc 746 - layer, // layer 747 - vds, // vds 748 - d); // d 754 + render, // 755 + d, // 756 + layer, // 757 + vds); // 758 + 749 759 } else if (layer_count > 0) { 760 + // Compute layer squasher 761 + if (fast_path) { 762 + U_LOG_W("Wanted fast path but no projection layer, falling back to layer squasher."); 763 + } 764 + 765 + 766 + /* 767 + * Layer squashing. 768 + */ 750 769 comp_render_cs_layers( // 751 - crc, // 770 + render, // 752 771 layers, // 753 772 layer_count, // 754 773 d, // 755 774 transition_to); // 756 775 776 + /* 777 + * Distortion. 778 + */ 779 + 757 780 do_cs_distortion_from_scratch( // 758 - crc, // 781 + render, // 759 782 d); // 760 783 } else { 784 + // Just clear the screen 761 785 do_cs_clear( // 762 - crc, // 786 + render, // 763 787 d); // 764 788 } 765 789 }

+113 -106

src/xrt/compositor/util/comp_render_gfx.c

··· 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 - * @brief Compositor gfx rendering code. 5 + * @brief Compositor (gfx - graphics shader) rendering code. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 * @author Rylie Pavlik <rylie.pavlik@collabora.com> 8 8 * @ingroup comp_util ··· 235 235 state->premultiplied_alphas[cur_layer] = !is_layer_unpremultiplied(data); 236 236 } 237 237 238 + /// Data setup for a cylinder layer 239 + /// Also allocates and writes a descriptor set! 238 240 static VkResult 239 - do_cylinder_layer(struct render_gfx *rr, 241 + do_cylinder_layer(struct render_gfx *render, 240 242 const struct comp_layer *layer, 241 243 uint32_t view_index, 242 244 VkSampler clamp_to_edge, ··· 248 250 const uint32_t array_index = c->sub.array_index; 249 251 const struct comp_swapchain_image *image = get_layer_image(layer, 0, c->sub.image_index); 250 252 251 - struct vk_bundle *vk = rr->r->vk; 253 + struct vk_bundle *vk = render->r->vk; 252 254 VkResult ret; 253 255 254 256 // Color ··· 285 287 // Can fail if we have too many layers. 286 288 VkDescriptorSet descriptor_set = VK_NULL_HANDLE; 287 289 ret = render_gfx_layer_cylinder_alloc_and_write( // 288 - rr, // rr 289 - &data, // data 290 - src_sampler, // src_sampler 291 - src_image_view, // src_image_view 290 + render, // 291 + &data, // 292 + src_sampler, // 293 + src_image_view, // 292 294 &descriptor_set); // out_descriptor_set 293 295 VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); 294 296 ··· 299 301 return VK_SUCCESS; 300 302 } 301 303 304 + /// Data setup for an "equirect2" layer 305 + /// Also allocates and writes a descriptor set! 302 306 static VkResult 303 - do_equirect2_layer(struct render_gfx *rr, 307 + do_equirect2_layer(struct render_gfx *render, 304 308 const struct comp_layer *layer, 305 309 uint32_t view_index, 306 310 VkSampler clamp_to_edge, ··· 312 316 const uint32_t array_index = eq2->sub.array_index; 313 317 const struct comp_swapchain_image *image = get_layer_image(layer, 0, eq2->sub.image_index); 314 318 315 - struct vk_bundle *vk = rr->r->vk; 319 + struct vk_bundle *vk = render->r->vk; 316 320 VkResult ret; 317 321 318 322 // Color ··· 349 353 // Can fail if we have too many layers. 350 354 VkDescriptorSet descriptor_set = VK_NULL_HANDLE; 351 355 ret = render_gfx_layer_equirect2_alloc_and_write( // 352 - rr, // rr 353 - &data, // data 354 - src_sampler, // src_sampler 355 - src_image_view, // src_image_view 356 + render, // 357 + &data, // 358 + src_sampler, // 359 + src_image_view, // 356 360 &descriptor_set); // out_descriptor_set 357 361 VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); 358 362 ··· 363 367 return VK_SUCCESS; 364 368 } 365 369 370 + /// Data setup for a projection layer 371 + /// Also allocates and writes a descriptor set! 366 372 static VkResult 367 - do_projection_layer(struct render_gfx *rr, 373 + do_projection_layer(struct render_gfx *render, 368 374 const struct comp_layer *layer, 369 375 uint32_t view_index, 370 376 VkSampler clamp_to_edge, ··· 385 391 uint32_t array_index = vd->sub.array_index; 386 392 const struct comp_swapchain_image *image = get_layer_image(layer, sc_array_index, vd->sub.image_index); 387 393 388 - struct vk_bundle *vk = rr->r->vk; 394 + struct vk_bundle *vk = render->r->vk; 389 395 VkResult ret; 390 396 // Color 391 397 VkSampler src_sampler = clamp_to_border_black; ··· 411 417 // Can fail if we have too many layers. 412 418 VkDescriptorSet descriptor_set = VK_NULL_HANDLE; 413 419 ret = render_gfx_layer_projection_alloc_and_write( // 414 - rr, // rr 415 - &data, // data 416 - src_sampler, // src_sampler 417 - src_image_view, // src_image_view 420 + render, // 421 + &data, // 422 + src_sampler, // 423 + src_image_view, // 418 424 &descriptor_set); // out_descriptor_set 419 425 VK_CHK_AND_RET(ret, "render_gfx_layer_projection_alloc_and_write"); 420 426 ··· 425 431 return VK_SUCCESS; 426 432 } 427 433 434 + /// Data setup for a quad layer 435 + /// Also allocates and writes a descriptor set! 428 436 static VkResult 429 - do_quad_layer(struct render_gfx *rr, 437 + do_quad_layer(struct render_gfx *render, 430 438 const struct comp_layer *layer, 431 439 uint32_t view_index, 432 440 VkSampler clamp_to_edge, ··· 438 446 const uint32_t array_index = q->sub.array_index; 439 447 const struct comp_swapchain_image *image = get_layer_image(layer, 0, q->sub.image_index); 440 448 441 - struct vk_bundle *vk = rr->r->vk; 449 + struct vk_bundle *vk = render->r->vk; 442 450 VkResult ret; 443 451 444 452 // Color ··· 462 470 // Can fail if we have too many layers. 463 471 VkDescriptorSet descriptor_set = VK_NULL_HANDLE; 464 472 ret = render_gfx_layer_quad_alloc_and_write( // 465 - rr, // rr 466 - &data, // data 467 - src_sampler, // src_sampler 468 - src_image_view, // src_image_view 473 + render, // 474 + &data, // 475 + src_sampler, // 476 + src_image_view, // 469 477 &descriptor_set); // out_descriptor_set 470 478 VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); 471 479 ··· 477 485 } 478 486 479 487 static void 480 - do_layers(struct render_gfx *rr, 488 + do_layers(struct render_gfx *render, 481 489 const struct comp_layer *layers, 482 490 uint32_t layer_count, 483 491 const struct comp_render_dispatch_data *d) 484 492 { 485 493 COMP_TRACE_MARKER(); 486 494 487 - struct vk_bundle *vk = rr->r->vk; 495 + struct vk_bundle *vk = render->r->vk; 488 496 VkResult ret; 489 497 490 498 struct gfx_layer_state ls = XRT_STRUCT_INIT; ··· 538 546 539 547 assert(layer_count <= RENDER_MAX_LAYERS && "Too many layers"); 540 548 541 - VkSampler clamp_to_edge = rr->r->samplers.clamp_to_edge; 542 - VkSampler clamp_to_border_black = rr->r->samplers.clamp_to_border_black; 549 + VkSampler clamp_to_edge = render->r->samplers.clamp_to_edge; 550 + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 543 551 544 552 for (uint32_t view = 0; view < d->view_count; view++) { 545 553 ··· 555 563 switch (data->type) { 556 564 case XRT_LAYER_CYLINDER: 557 565 ret = do_cylinder_layer( // 558 - rr, // rr 559 - &layers[i], // layer 566 + render, // 567 + &layers[i], // 560 568 view, // view_index 561 - clamp_to_edge, // clamp_to_edge 562 - clamp_to_border_black, // clamp_to_border_black 563 - state); // state 569 + clamp_to_edge, // 570 + clamp_to_border_black, // 571 + state); // 564 572 VK_CHK_WITH_GOTO(ret, "do_cylinder_layer", err_layer); 565 573 break; 566 574 case XRT_LAYER_EQUIRECT2: 567 575 ret = do_equirect2_layer( // 568 - rr, // rr 569 - &layers[i], // layer 576 + render, // 577 + &layers[i], // 570 578 view, // view_index 571 - clamp_to_edge, // clamp_to_edge 572 - clamp_to_border_black, // clamp_to_border_black 573 - state); // state 579 + clamp_to_edge, // 580 + clamp_to_border_black, // 581 + state); // 574 582 VK_CHK_WITH_GOTO(ret, "do_equirect2_layer", err_layer); 575 583 break; 576 584 case XRT_LAYER_PROJECTION: 577 585 case XRT_LAYER_PROJECTION_DEPTH: 578 586 ret = do_projection_layer( // 579 - rr, // rr 580 - &layers[i], // layer 587 + render, // 588 + &layers[i], // 581 589 view, // view_index 582 - clamp_to_edge, // clamp_to_edge 583 - clamp_to_border_black, // clamp_to_border_black 584 - state); // state 590 + clamp_to_edge, // 591 + clamp_to_border_black, // 592 + state); // 585 593 VK_CHK_WITH_GOTO(ret, "do_projection_layer", err_layer); 586 594 break; 587 595 case XRT_LAYER_QUAD: 588 596 ret = do_quad_layer( // 589 - rr, // rr 590 - &layers[i], // layer 597 + render, // 598 + &layers[i], // 591 599 view, // view_index 592 - clamp_to_edge, // clamp_to_edge 593 - clamp_to_border_black, // clamp_to_border_black 594 - state); // state 600 + clamp_to_edge, // 601 + clamp_to_border_black, // 602 + state); // 595 603 VK_CHK_WITH_GOTO(ret, "do_quad_layer", err_layer); 596 604 break; 597 605 default: break; ··· 612 620 const struct render_viewport_data *viewport_data = &d->views[view].layer_viewport_data; 613 621 614 622 render_gfx_begin_target( // 615 - rr, // 623 + render, // 616 624 d->views[view].gfx.rtr, // 617 625 color); // 618 626 619 627 render_gfx_begin_view( // 620 - rr, // 628 + render, // 621 629 view, // view_index 622 630 viewport_data); // viewport_data 623 631 ··· 628 636 switch (state->types[i]) { 629 637 case XRT_LAYER_CYLINDER: 630 638 render_gfx_layer_cylinder( // 631 - rr, // 639 + render, // 632 640 state->premultiplied_alphas[i], // 633 641 state->descriptor_sets[i]); // 634 642 break; 635 643 case XRT_LAYER_EQUIRECT2: 636 644 render_gfx_layer_equirect2( // 637 - rr, // 645 + render, // 638 646 state->premultiplied_alphas[i], // 639 647 state->descriptor_sets[i]); // 640 648 break; 641 649 case XRT_LAYER_PROJECTION: 642 650 case XRT_LAYER_PROJECTION_DEPTH: 643 651 render_gfx_layer_projection( // 644 - rr, // 652 + render, // 645 653 state->premultiplied_alphas[i], // 646 654 state->descriptor_sets[i]); // 647 655 break; 648 656 case XRT_LAYER_QUAD: 649 657 render_gfx_layer_quad( // 650 - rr, // 658 + render, // 651 659 state->premultiplied_alphas[i], // 652 660 state->descriptor_sets[i]); // 653 661 break; ··· 655 663 } 656 664 } 657 665 658 - render_gfx_end_view(rr); 666 + render_gfx_end_view(render); 659 667 660 - render_gfx_end_target(rr); 668 + render_gfx_end_target(render); 661 669 } 662 670 663 671 ··· 676 684 */ 677 685 678 686 static void 679 - do_mesh(struct render_gfx *rr, 687 + do_mesh(struct render_gfx *render, 680 688 bool do_timewarp, 681 689 const struct gfx_mesh_data *md, 682 690 const struct comp_render_dispatch_data *d) 683 691 { 684 - struct vk_bundle *vk = rr->r->vk; 692 + struct vk_bundle *vk = render->r->vk; 685 693 VkResult ret; 686 694 687 695 /* ··· 711 719 } 712 720 713 721 ret = render_gfx_mesh_alloc_and_write( // 714 - rr, // 722 + render, // 715 723 &data, // 716 724 md->views[i].src_sampler, // 717 725 md->views[i].src_image_view, // ··· 727 735 */ 728 736 729 737 render_gfx_begin_target( // 730 - rr, // 738 + render, // 731 739 d->gfx.rtr, // 732 740 &background_color_active); // 733 741 ··· 736 744 const struct render_viewport_data *viewport_data = &d->views[i].target_viewport_data; 737 745 738 746 render_gfx_begin_view( // 739 - rr, // 747 + render, // 740 748 i, // view_index 741 - viewport_data); // viewport_data 749 + viewport_data); // 742 750 743 751 render_gfx_mesh_draw( // 744 - rr, // rr 752 + render, // 745 753 i, // mesh_index 746 - ms.descriptor_sets[i], // descriptor_set 747 - do_timewarp); // do_timewarp 754 + ms.descriptor_sets[i], // 755 + do_timewarp); // 748 756 749 - render_gfx_end_view(rr); 757 + render_gfx_end_view(render); 750 758 } 751 759 752 - render_gfx_end_target(rr); 760 + render_gfx_end_target(render); 753 761 754 762 return; 755 763 ··· 759 767 } 760 768 761 769 static void 762 - do_mesh_from_proj(struct render_gfx *rr, 770 + do_mesh_from_proj(struct render_gfx *render, 763 771 const struct comp_render_dispatch_data *d, 764 772 const struct comp_layer *layer, 765 773 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 766 774 { 767 775 const struct xrt_layer_data *data = &layer->data; 768 776 769 - const VkSampler clamp_to_border_black = rr->r->samplers.clamp_to_border_black; 777 + const VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 770 778 771 779 struct gfx_mesh_data md = XRT_STRUCT_INIT; 772 780 for (uint32_t i = 0; i < d->view_count; i++) { ··· 799 807 } 800 808 801 809 do_mesh( // 802 - rr, // 810 + render, // 803 811 d->do_timewarp, // 804 812 &md, // 805 813 d); // ··· 813 821 */ 814 822 815 823 void 816 - comp_render_gfx_dispatch(struct render_gfx *rr, 824 + comp_render_gfx_dispatch(struct render_gfx *render, 817 825 const struct comp_layer *layers, 818 826 const uint32_t layer_count, 819 827 const struct comp_render_dispatch_data *d) ··· 831 839 // Fast path. 832 840 const struct xrt_layer_projection_data *proj = &layer->data.proj; 833 841 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 834 - for (uint32_t j = 0; j < d->view_count; ++j) { 835 - vds[j] = &proj->v[j]; 842 + for (uint32_t view = 0; view < d->view_count; ++view) { 843 + vds[view] = &proj->v[view]; 836 844 } 837 845 do_mesh_from_proj( // 838 - rr, // 846 + render, // 839 847 d, // 840 848 layer, // 841 849 vds); // ··· 848 856 vds[view] = &depth->v[view]; 849 857 } 850 858 do_mesh_from_proj( // 851 - rr, // 859 + render, // 852 860 d, // 853 861 layer, // 854 862 vds); // 855 863 856 - } else if (layer_count == 0) { 857 - // Just clear the screen 858 - render_gfx_begin_target( // 859 - rr, // 860 - d->gfx.rtr, // 861 - &background_color_idle); // 862 - 863 - render_gfx_end_target(rr); 864 - } else { 864 + } else if (layer_count > 0) { 865 + // Graphics layer squasher 865 866 if (fast_path) { 866 867 U_LOG_W("Wanted fast path but no projection layer, falling back to layer squasher."); 867 868 } ··· 870 871 /* 871 872 * Layer squashing. 872 873 */ 873 - 874 874 do_layers( // 875 - rr, // rr 876 - layers, // layers 877 - layer_count, // layer_count 878 - d); // d 879 - 875 + render, // 876 + layers, // 877 + layer_count, // 878 + d); // 880 879 881 880 /* 882 881 * Distortion. ··· 886 885 VkImageLayout transition_to = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; 887 886 888 887 cmd_barrier_view_images( // 889 - rr->r->vk, // 888 + render->r->vk, // 890 889 d, // 891 - rr->r->cmd, // cmd 890 + render->r->cmd, // cmd 892 891 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // src_access_mask 893 892 VK_ACCESS_SHADER_READ_BIT, // dst_access_mask 894 - transition_from, // transition_from 895 - transition_to, // transition_to 893 + transition_from, // 894 + transition_to, // 896 895 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // src_stage_mask 897 896 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); // dst_stage_mask 898 897 899 898 // Shared between all views. 900 - VkSampler clamp_to_border_black = rr->r->samplers.clamp_to_border_black; 899 + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 901 900 902 901 struct gfx_mesh_data md = XRT_STRUCT_INIT; 903 902 for (uint32_t i = 0; i < d->view_count; i++) { ··· 907 906 struct xrt_normalized_rect src_norm_rect = d->views[i].layer_norm_rect; 908 907 909 908 gfx_mesh_add_view( // 910 - &md, // md 909 + &md, // 911 910 i, // view_index 912 - &src_pose, // src_pose 913 - &src_fov, // src_fov 914 - &src_norm_rect, // src_norm_rect 911 + &src_pose, // 912 + &src_fov, // 913 + &src_norm_rect, // 915 914 clamp_to_border_black, // src_sampler 916 - src_image_view); // src_image_view 915 + src_image_view); // 917 916 } 918 917 919 918 // We are passing in the same old and new poses. 920 - do_mesh( // 921 - rr, // 922 - false, // do_timewarp 923 - &md, // md 924 - d); // d 919 + do_mesh( // 920 + render, // 921 + false, // do_timewarp 922 + &md, // 923 + d); // 924 + } else { 925 + // 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); 925 932 } 926 933 }

Configure Feed

Configure Feed