+47 -34

src/xrt/compositor/main/comp_renderer.c

··· 962 962 963 963 // The arguments for the dispatch function. 964 964 struct comp_render_dispatch_data data; 965 965 - comp_render_gfx_initial_init( // 966 966 - &data, // data 967 967 - rtr, // rtr 968 968 - fast_path, // fast_path 969 969 - do_timewarp); // do_timewarp 965 965 + comp_render_initial_init( // 966 966 + &data, // data 967 967 + fast_path, // fast_path 968 968 + do_timewarp); // do_timewarp 969 969 + 970 970 for (uint32_t i = 0; i < render->r->view_count; i++) { 971 971 // Which image of the scratch images for this view are we using. 972 972 uint32_t scratch_index = crss->views[i].index; ··· 993 993 994 994 VkImageView sample_view = comp_scratch_single_images_get_sample_view(scratch_view, scratch_index); 995 995 996 996 - comp_render_gfx_add_view( // 997 997 - &data, // 998 998 - &world_poses[i], // 999 999 - &eye_poses[i], // 1000 1000 - &fovs[i], // 1001 1001 - rsci->image, // squash_image 1002 1002 - rsci_rtr, // squash_rtr 1003 1003 - &layer_viewport_data, // squash_viewport_data 1004 1004 - sample_view, // squash_as_src_sample_view 1005 1005 - &layer_norm_rect, // squash_as_src_norm_rect 1006 1006 - &vertex_rots[i], // target_vertex_rot 1007 1007 - &viewport_datas[i]); // target_viewport_data 996 996 + comp_render_gfx_add_squash_view( // 997 997 + &data, // 998 998 + &world_poses[i], // 999 999 + &eye_poses[i], // 1000 1000 + &fovs[i], // 1001 1001 + rsci->image, // squash_image 1002 1002 + rsci_rtr, // squash_rtr 1003 1003 + &layer_viewport_data); // squash_viewport_data 1004 1004 + 1005 1005 + comp_render_gfx_add_target_view( // 1006 1006 + &data, // 1007 1007 + sample_view, // squash_as_src_sample_view 1008 1008 + &layer_norm_rect, // squash_as_src_norm_rect 1009 1009 + &vertex_rots[i], // target_vertex_rot 1010 1010 + &viewport_datas[i]); // target_viewport_data 1008 1011 1009 1012 if (layer_count == 0) { 1010 1013 crss->views[i].used = false; ··· 1012 1015 crss->views[i].used = !fast_path; 1013 1016 } 1014 1017 } 1018 1018 + 1019 1019 + // Add the target info. 1020 1020 + comp_render_gfx_add_target(&data, rtr); 1015 1021 1016 1022 // Start the graphics pipeline. 1017 1023 render_gfx_begin(render); ··· 1083 1089 1084 1090 // The arguments for the dispatch function. 1085 1091 struct comp_render_dispatch_data data; 1086 1086 - comp_render_cs_initial_init( // 1087 1087 - &data, // data 1088 1088 - target_image, // target_image 1089 1089 - target_image_view, // target_unorm_view 1090 1090 - fast_path, // fast_path 1091 1091 - do_timewarp); // do_timewarp 1092 1092 + comp_render_initial_init( // 1093 1093 + &data, // data 1094 1094 + fast_path, // fast_path 1095 1095 + do_timewarp); // do_timewarp 1092 1096 1093 1097 for (uint32_t i = 0; i < render->r->view_count; i++) { 1094 1098 // Which image of the scratch images for this view are we using. ··· 1114 1118 VkImageView sample_view = comp_scratch_single_images_get_sample_view(scratch_view, scratch_index); 1115 1119 VkImageView storage_view = comp_scratch_single_images_get_storage_view(scratch_view, scratch_index); 1116 1120 1117 1117 - comp_render_cs_add_view( // 1118 1118 - &data, // 1119 1119 - &world_poses[i], // 1120 1120 - &eye_poses[i], // 1121 1121 - &fovs[i], // 1122 1122 - rsci->image, // squash_image 1123 1123 - storage_view, // squash_storage_view 1124 1124 - &layer_viewport_data, // squash_viewport_data 1125 1125 - sample_view, // squash_as_src_sample_view 1126 1126 - &layer_norm_rect, // squash_as_src_norm_rect 1127 1127 - &views[i]); // target_viewport_data 1121 1121 + comp_render_cs_add_squash_view( // 1122 1122 + &data, // 1123 1123 + &world_poses[i], // 1124 1124 + &eye_poses[i], // 1125 1125 + &fovs[i], // 1126 1126 + rsci->image, // squash_image 1127 1127 + storage_view, // squash_storage_view 1128 1128 + &layer_viewport_data); // squash_viewport_data 1129 1129 + 1130 1130 + comp_render_cs_add_target_view( // 1131 1131 + &data, // 1132 1132 + sample_view, // squash_as_src_sample_view 1133 1133 + &layer_norm_rect, // squash_as_src_norm_rect 1134 1134 + &views[i]); // target_viewport_data 1128 1135 1129 1136 if (layer_count == 0) { 1130 1137 crss->views[i].used = false; ··· 1132 1139 crss->views[i].used = !fast_path; 1133 1140 } 1134 1141 } 1142 1142 + 1143 1143 + // Add the target info. 1144 1144 + comp_render_cs_add_target( // 1145 1145 + &data, // data 1146 1146 + target_image, // target_image 1147 1147 + target_image_view); // target_unorm_view 1135 1148 1136 1149 // Start the compute pipeline. 1137 1150 render_compute_begin(render);

+119 -77

src/xrt/compositor/util/comp_render.h

··· 164 164 { 165 165 struct comp_render_view_data views[XRT_MAX_VIEWS]; 166 166 167 167 - //! The number of views currently in this dispatch data. 168 168 - uint32_t view_count; 167 167 + /*! 168 168 + * The number of squash views currently in this dispatch data. 169 169 + */ 170 170 + uint32_t squash_view_count; 171 171 + 169 172 170 173 //! Fast path can be disabled for mirroing so needs to be an argument. 171 174 bool fast_path; ··· 175 178 176 179 struct 177 180 { 181 181 + //! Has this struct been setup to use the target. 182 182 + bool initialized; 183 183 + 184 184 + /*! 185 185 + * The number of target views currently, when calling dispatch 186 186 + * this has to be either zero or the same number as 187 187 + * squash_view_count, see also the target.initialized field. 188 188 + */ 189 189 + uint32_t view_count; 190 190 + 178 191 //! Members used only by GFX @ref comp_render_gfx 179 192 struct 180 193 { ··· 195 208 }; 196 209 197 210 /*! 211 211 + * Initialize structure for use without the target step. 212 212 + * 213 213 + * @param[out] data Common render dispatch data. Will be zeroed and initialized. 214 214 + * @param fast_path Whether we will use the "fast path" avoiding layer squashing. 215 215 + * @param do_timewarp Whether timewarp (reprojection) will be performed. 216 216 + */ 217 217 + static inline void 218 218 + comp_render_initial_init(struct comp_render_dispatch_data *data, bool fast_path, bool do_timewarp) 219 219 + { 220 220 + U_ZERO(data); 221 221 + 222 222 + data->fast_path = fast_path; 223 223 + data->do_timewarp = do_timewarp; 224 224 + } 225 225 + 226 226 + /*! 198 227 * Shared implementation setting up common view params between GFX and CS. 199 228 * 200 229 * Private implementation method, do not use outside of more-specific add_view calls! ··· 220 249 * @return Pointer to the @ref comp_render_view_data we have been populating, for additional setup. 221 250 */ 222 251 static inline struct comp_render_view_data * 223 223 - comp_render_dispatch_add_view(struct comp_render_dispatch_data *data, 224 224 - const struct xrt_pose *world_pose, 225 225 - const struct xrt_pose *eye_pose, 226 226 - const struct xrt_fov *fov, 227 227 - VkImage squash_image, 228 228 - const struct render_viewport_data *squash_viewport_data, 229 229 - VkImageView squash_as_src_sample_view, 230 230 - const struct xrt_normalized_rect *squash_as_src_norm_rect, 231 231 - const struct render_viewport_data *target_viewport_data) 252 252 + comp_render_dispatch_add_squash_view(struct comp_render_dispatch_data *data, 253 253 + const struct xrt_pose *world_pose, 254 254 + const struct xrt_pose *eye_pose, 255 255 + const struct xrt_fov *fov, 256 256 + VkImage squash_image, 257 257 + const struct render_viewport_data *squash_viewport_data) 232 258 { 233 233 - uint32_t i = data->view_count++; 259 259 + uint32_t i = data->squash_view_count++; 234 260 235 261 assert(i < ARRAY_SIZE(data->views)); 236 262 ··· 247 273 view->squash.image = squash_image; 248 274 view->squash.viewport_data = *squash_viewport_data; 249 275 276 276 + return view; 277 277 + } 278 278 + 279 279 + static inline struct comp_render_view_data * 280 280 + comp_render_dispatch_add_target_view(struct comp_render_dispatch_data *data, 281 281 + VkImageView squash_as_src_sample_view, 282 282 + const struct xrt_normalized_rect *squash_as_src_norm_rect, 283 283 + const struct render_viewport_data *target_viewport_data) 284 284 + { 285 285 + uint32_t i = data->target.view_count++; 286 286 + 287 287 + assert(i < data->squash_view_count); 288 288 + assert(i < ARRAY_SIZE(data->views)); 289 289 + 290 290 + struct comp_render_view_data *view = &data->views[i]; 291 291 + 250 292 // When using the squash (aka scratch) image as a source. 251 293 view->squash_as_src.sample_view = squash_as_src_sample_view; 252 294 view->squash_as_src.norm_rect = *squash_as_src_norm_rect; ··· 281 323 /*! 282 324 * Initialize structure for use of the GFX renderer. 283 325 * 284 284 - * @param[out] data Common render dispatch data. Will be zeroed and initialized. 326 326 + * @param[in,out] data Common render dispatch data. 285 327 * @param target_rtr GFX-specific resources for the entire framebuffer. Must be populated before call. 286 286 - * @param fast_path Whether we will use the "fast path" avoiding layer squashing. 287 287 - * @param do_timewarp Whether timewarp (reprojection) will be performed. 288 328 */ 289 329 static inline void 290 290 - comp_render_gfx_initial_init(struct comp_render_dispatch_data *data, 291 291 - struct render_gfx_target_resources *target_rtr, 292 292 - bool fast_path, 293 293 - bool do_timewarp) 330 330 + comp_render_gfx_add_target(struct comp_render_dispatch_data *data, struct render_gfx_target_resources *target_rtr) 294 331 { 295 295 - U_ZERO(data); 296 296 - 297 297 - data->fast_path = fast_path; 298 298 - data->do_timewarp = do_timewarp; 332 332 + // Error tracking. 333 333 + data->target.initialized = true; 299 334 300 335 // When writing into the target. 301 336 data->target.gfx.rtr = target_rtr; ··· 327 362 * Populates @ref comp_render_view_data::target.viewport_data 328 363 */ 329 364 static inline void 330 330 - comp_render_gfx_add_view(struct comp_render_dispatch_data *data, 331 331 - const struct xrt_pose *world_pose, 332 332 - const struct xrt_pose *eye_pose, 333 333 - const struct xrt_fov *fov, 334 334 - VkImage squash_image, 335 335 - struct render_gfx_target_resources *squash_rtr, 336 336 - const struct render_viewport_data *layer_viewport_data, 337 337 - VkImageView squash_as_src_sample_view, 338 338 - const struct xrt_normalized_rect *squash_as_src_norm_rect, 339 339 - const struct xrt_matrix_2x2 *target_vertex_rot, 340 340 - const struct render_viewport_data *target_viewport_data) 365 365 + comp_render_gfx_add_squash_view(struct comp_render_dispatch_data *data, 366 366 + const struct xrt_pose *world_pose, 367 367 + const struct xrt_pose *eye_pose, 368 368 + const struct xrt_fov *fov, 369 369 + VkImage squash_image, 370 370 + struct render_gfx_target_resources *squash_rtr, 371 371 + const struct render_viewport_data *layer_viewport_data) 341 372 { 342 342 - struct comp_render_view_data *view = comp_render_dispatch_add_view( // 343 343 - data, // 344 344 - world_pose, // 345 345 - eye_pose, // 346 346 - fov, // 347 347 - squash_image, // 348 348 - layer_viewport_data, // 349 349 - squash_as_src_sample_view, // 350 350 - squash_as_src_norm_rect, // 351 351 - target_viewport_data); 373 373 + struct comp_render_view_data *view = comp_render_dispatch_add_squash_view( // 374 374 + data, // 375 375 + world_pose, // 376 376 + eye_pose, // 377 377 + fov, // 378 378 + squash_image, // 379 379 + layer_viewport_data); // 352 380 353 381 // When writing into the squash (aka scratch) image. 354 382 view->squash.gfx.rtr = squash_rtr; 383 383 + } 384 384 + 385 385 + static inline void 386 386 + comp_render_gfx_add_target_view(struct comp_render_dispatch_data *data, 387 387 + VkImageView squash_as_src_sample_view, 388 388 + const struct xrt_normalized_rect *squash_as_src_norm_rect, 389 389 + const struct xrt_matrix_2x2 *target_vertex_rot, 390 390 + const struct render_viewport_data *target_viewport_data) 391 391 + { 392 392 + struct comp_render_view_data *view = comp_render_dispatch_add_target_view( // 393 393 + data, // 394 394 + squash_as_src_sample_view, // 395 395 + squash_as_src_norm_rect, // 396 396 + target_viewport_data); // 355 397 356 398 // When writing into the target. 357 399 view->target.gfx.vertex_rot = *target_vertex_rot; ··· 454 496 */ 455 497 456 498 /*! 457 457 - * Initialize structure for use of the CS renderer. 499 499 + * Add the target info, as required by the CS renderer. 458 500 * 459 459 - * @param data Common render dispatch data. Will be zeroed and initialized. 501 501 + * @param[in,out] data Common render dispatch data. 460 502 * @param target_image Image to render into 461 503 * @param target_storage_view Corresponding image view 462 462 - * @param fast_path Whether we will use the "fast path" avoiding layer squashing. 463 463 - * @param do_timewarp Whether timewarp (reprojection) will be performed. 464 504 */ 465 505 static inline void 466 466 - comp_render_cs_initial_init(struct comp_render_dispatch_data *data, 467 467 - VkImage target_image, 468 468 - VkImageView target_storage_view, 469 469 - bool fast_path, 470 470 - bool do_timewarp) 506 506 + comp_render_cs_add_target(struct comp_render_dispatch_data *data, VkImage target_image, VkImageView target_storage_view) 471 507 { 472 472 - U_ZERO(data); 473 473 - 474 474 - data->fast_path = fast_path; 475 475 - data->do_timewarp = do_timewarp; 508 508 + // Error tracking. 509 509 + data->target.initialized = true; 476 510 477 511 // When writing into the target. 478 512 data->target.cs.image = target_image; ··· 502 536 * Populates @ref comp_render_view_data::target::viewport_data 503 537 */ 504 538 static inline void 505 505 - comp_render_cs_add_view(struct comp_render_dispatch_data *data, 506 506 - const struct xrt_pose *world_pose, 507 507 - const struct xrt_pose *eye_pose, 508 508 - const struct xrt_fov *fov, 509 509 - VkImage squash_image, 510 510 - VkImageView squash_storage_view, 511 511 - const struct render_viewport_data *squash_viewport_data, 512 512 - VkImageView squash_as_src_sample_view, 513 513 - const struct xrt_normalized_rect *squash_as_src_norm_rect, 514 514 - const struct render_viewport_data *target_viewport_data) 539 539 + comp_render_cs_add_squash_view(struct comp_render_dispatch_data *data, 540 540 + const struct xrt_pose *world_pose, 541 541 + const struct xrt_pose *eye_pose, 542 542 + const struct xrt_fov *fov, 543 543 + VkImage squash_image, 544 544 + VkImageView squash_storage_view, 545 545 + const struct render_viewport_data *squash_viewport_data) 515 546 { 516 516 - struct comp_render_view_data *view = comp_render_dispatch_add_view( // 517 517 - data, // 518 518 - world_pose, // 519 519 - eye_pose, // 520 520 - fov, // 521 521 - squash_image, // 522 522 - squash_viewport_data, // 523 523 - squash_as_src_sample_view, // 524 524 - squash_as_src_norm_rect, // 525 525 - target_viewport_data); // 547 547 + struct comp_render_view_data *view = comp_render_dispatch_add_squash_view( // 548 548 + data, // 549 549 + world_pose, // 550 550 + eye_pose, // 551 551 + fov, // 552 552 + squash_image, // 553 553 + squash_viewport_data); // 526 554 527 555 // When writing into the squash (aka scratch) image. 528 556 view->squash.cs.storage_view = squash_storage_view; 557 557 + } 558 558 + 559 559 + static inline void 560 560 + comp_render_cs_add_target_view(struct comp_render_dispatch_data *data, 561 561 + VkImageView squash_as_src_sample_view, 562 562 + const struct xrt_normalized_rect *squash_as_src_norm_rect, 563 563 + const struct render_viewport_data *target_viewport_data) 564 564 + { 565 565 + struct comp_render_view_data *view = comp_render_dispatch_add_target_view( // 566 566 + data, // 567 567 + squash_as_src_sample_view, // 568 568 + squash_as_src_norm_rect, // 569 569 + target_viewport_data); // 570 570 + (void)view; 529 571 } 530 572 531 573 /*!

+18 -12

src/xrt/compositor/util/comp_render_cs.c

··· 332 332 static void 333 333 crc_clear_output(struct render_compute *render, const struct comp_render_dispatch_data *d) 334 334 { 335 335 - if (d->view_count > XRT_MAX_VIEWS) { 335 335 + if (d->target.view_count > XRT_MAX_VIEWS) { 336 336 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); 337 337 - assert(d->view_count < XRT_MAX_VIEWS); 337 337 + assert(d->target.view_count <= XRT_MAX_VIEWS); 338 338 return; 339 339 } 340 340 341 341 struct render_viewport_data target_viewport_datas[XRT_MAX_VIEWS]; 342 342 - for (uint32_t i = 0; i < d->view_count; ++i) { 342 342 + for (uint32_t i = 0; i < d->target.view_count; ++i) { 343 343 target_viewport_datas[i] = d->views[i].target.viewport_data; 344 344 } 345 345 ··· 361 361 static void 362 362 crc_distortion_after_squash(struct render_compute *render, const struct comp_render_dispatch_data *d) 363 363 { 364 364 - if (d->view_count > XRT_MAX_VIEWS) { 364 364 + if (d->target.view_count > XRT_MAX_VIEWS) { 365 365 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); 366 366 - assert(d->view_count < XRT_MAX_VIEWS); 366 366 + assert(d->target.view_count <= XRT_MAX_VIEWS); 367 367 return; 368 368 } 369 369 VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; ··· 374 374 struct render_viewport_data target_viewport_datas[XRT_MAX_VIEWS]; 375 375 struct xrt_normalized_rect src_norm_rects[XRT_MAX_VIEWS]; 376 376 377 377 - for (uint32_t i = 0; i < d->view_count; i++) { 377 377 + for (uint32_t i = 0; i < d->target.view_count; i++) { 378 378 // Data to be filled in. 379 379 VkImageView src_image_view; 380 380 struct render_viewport_data viewport_data; ··· 409 409 const struct comp_layer *layer, 410 410 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) 411 411 { 412 412 - if (d->view_count > XRT_MAX_VIEWS) { 412 412 + if (d->target.view_count > XRT_MAX_VIEWS) { 413 413 U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); 414 414 - assert(d->view_count < XRT_MAX_VIEWS); 414 414 + assert(d->target.view_count <= XRT_MAX_VIEWS); 415 415 return; 416 416 } 417 417 ··· 429 429 struct xrt_pose src_poses[XRT_MAX_VIEWS]; 430 430 struct xrt_pose world_poses[XRT_MAX_VIEWS]; 431 431 432 432 - for (uint32_t i = 0; i < d->view_count; i++) { 432 432 + for (uint32_t i = 0; i < d->target.view_count; i++) { 433 433 // Data to be filled in. 434 434 VkImageView src_image_view; 435 435 struct render_viewport_data viewport_data; ··· 684 684 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // src_stage_mask 685 685 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); // dst_stage_mask 686 686 687 687 - for (uint32_t view_index = 0; view_index < d->view_count; view_index++) { 687 687 + for (uint32_t view_index = 0; view_index < d->squash_view_count; view_index++) { 688 688 const struct comp_render_view_data *view = &d->views[view_index]; 689 689 690 690 comp_render_cs_layer( // ··· 719 719 const uint32_t layer_count, 720 720 const struct comp_render_dispatch_data *d) 721 721 { 722 722 + if (!d->target.initialized) { 723 723 + VK_ERROR(render->r->vk, "Target hasn't been initialized, not rendering anything."); 724 724 + assert(d->target.initialized); 725 725 + return; 726 726 + } 727 727 + 722 728 // Convenience. 723 729 bool fast_path = d->fast_path; 724 730 ··· 735 741 // Fast path. 736 742 const struct xrt_layer_projection_data *proj = &layer->data.proj; 737 743 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 738 738 - for (uint32_t view = 0; view < d->view_count; ++view) { 744 744 + for (uint32_t view = 0; view < d->target.view_count; ++view) { 739 745 vds[view] = &proj->v[view]; 740 746 } 741 747 crc_distortion_fast_path( // ··· 748 754 // Fast path. 749 755 const struct xrt_layer_projection_depth_data *depth = &layer->data.depth; 750 756 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 751 751 - for (uint32_t view = 0; view < d->view_count; ++view) { 757 757 + for (uint32_t view = 0; view < d->target.view_count; ++view) { 752 758 vds[view] = &depth->v[view]; 753 759 } 754 760 crc_distortion_fast_path( //

+15 -9

src/xrt/compositor/util/comp_render_gfx.c

··· 520 520 521 521 struct gfx_mesh_state ms = XRT_STRUCT_INIT; 522 522 523 523 - for (uint32_t i = 0; i < d->view_count; i++) { 523 523 + for (uint32_t i = 0; i < d->target.view_count; i++) { 524 524 525 525 struct render_gfx_mesh_ubo_data data = { 526 526 .vertex_rot = d->views[i].target.gfx.vertex_rot, ··· 559 559 d->target.gfx.rtr, // 560 560 &background_color_active); // 561 561 562 562 - for (uint32_t i = 0; i < d->view_count; i++) { 562 562 + for (uint32_t i = 0; i < d->target.view_count; i++) { 563 563 // Convenience. 564 564 const struct render_viewport_data *viewport_data = &d->views[i].target.viewport_data; 565 565 ··· 595 595 VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 596 596 597 597 struct gfx_mesh_data md = XRT_STRUCT_INIT; 598 598 - for (uint32_t i = 0; i < d->view_count; i++) { 598 598 + for (uint32_t i = 0; i < d->target.view_count; i++) { 599 599 struct xrt_pose src_pose = d->views[i].world_pose; 600 600 struct xrt_fov src_fov = d->views[i].fov; 601 601 VkImageView src_image_view = d->views[i].squash_as_src.sample_view; ··· 631 631 const VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 632 632 633 633 struct gfx_mesh_data md = XRT_STRUCT_INIT; 634 634 - for (uint32_t i = 0; i < d->view_count; i++) { 634 634 + for (uint32_t i = 0; i < d->target.view_count; i++) { 635 635 const uint32_t array_index = vds[i]->sub.array_index; 636 636 637 637 const struct comp_swapchain_image *image = get_layer_image(layer, i, vds[i]->sub.image_index); ··· 690 690 691 691 // Compute MVP matrices per eye: populates gfx_layer_view_state elements in `ls` 692 692 // from `comp_render_dispatch_data *d` 693 693 - for (uint32_t view = 0; view < d->view_count; view++) { 693 693 + for (uint32_t view = 0; view < d->squash_view_count; view++) { 694 694 695 695 // Data for this view, convenience. 696 696 const struct xrt_pose world_pose = d->views[view].world_pose; ··· 740 740 VkSampler clamp_to_edge = render->r->samplers.clamp_to_edge; 741 741 VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; 742 742 743 743 - for (uint32_t view = 0; view < d->view_count; view++) { 743 743 + for (uint32_t view = 0; view < d->squash_view_count; view++) { 744 744 745 745 // Source for data and written to as well, read and write. 746 746 struct gfx_layer_view_state *state = &ls.views[view]; ··· 805 805 806 806 const VkClearColorValue *color = layer_count == 0 ? &background_color_idle : &background_color_active; 807 807 808 808 - for (uint32_t view = 0; view < d->view_count; view++) { 808 808 + for (uint32_t view = 0; view < d->squash_view_count; view++) { 809 809 810 810 // Convenience. 811 811 const struct render_viewport_data *viewport_data = &d->views[view].squash.viewport_data; ··· 886 886 const uint32_t layer_count, 887 887 const struct comp_render_dispatch_data *d) 888 888 { 889 889 + if (!d->target.initialized) { 890 890 + VK_ERROR(render->r->vk, "Target hasn't been initialized, not rendering anything."); 891 891 + assert(d->target.initialized); 892 892 + return; 893 893 + } 894 894 + 889 895 // Convenience. 890 896 bool fast_path = d->fast_path; 891 897 ··· 902 908 // Fast path. 903 909 const struct xrt_layer_projection_data *proj = &layer->data.proj; 904 910 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 905 905 - for (uint32_t view = 0; view < d->view_count; ++view) { 911 911 + for (uint32_t view = 0; view < d->target.view_count; ++view) { 906 912 vds[view] = &proj->v[view]; 907 913 } 908 914 crg_distortion_fast_path( // ··· 915 921 // Fast path. 916 922 const struct xrt_layer_projection_depth_data *depth = &layer->data.depth; 917 923 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 918 918 - for (uint32_t view = 0; view < d->view_count; ++view) { 924 924 + for (uint32_t view = 0; view < d->target.view_count; ++view) { 919 925 vds[view] = &depth->v[view]; 920 926 } 921 927 crg_distortion_fast_path( //

+1 -1

src/xrt/compositor/util/comp_render_helpers.h

··· 162 162 .layerCount = 1, 163 163 }; 164 164 165 165 - for (uint32_t i = 0; i < d->view_count; i++) { 165 165 + for (uint32_t i = 0; i < d->squash_view_count; i++) { 166 166 bool already_barriered = false; 167 167 168 168 VkImage image = d->views[i].squash.image;