The open source OpenXR runtime
c/util: Make target part optional
Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2493>
+200
-133
+47
-34
src/xrt/compositor/main/comp_renderer.c
+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
-
comp_render_gfx_initial_init( //
966
-
&data, // data
967
-
rtr, // rtr
968
-
fast_path, // fast_path
969
-
do_timewarp); // do_timewarp
965
+
comp_render_initial_init( //
966
+
&data, // data
967
+
fast_path, // fast_path
968
+
do_timewarp); // do_timewarp
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
-
comp_render_gfx_add_view( //
997
-
&data, //
998
-
&world_poses[i], //
999
-
&eye_poses[i], //
1000
-
&fovs[i], //
1001
-
rsci->image, // squash_image
1002
-
rsci_rtr, // squash_rtr
1003
-
&layer_viewport_data, // squash_viewport_data
1004
-
sample_view, // squash_as_src_sample_view
1005
-
&layer_norm_rect, // squash_as_src_norm_rect
1006
-
&vertex_rots[i], // target_vertex_rot
1007
-
&viewport_datas[i]); // target_viewport_data
996
+
comp_render_gfx_add_squash_view( //
997
+
&data, //
998
+
&world_poses[i], //
999
+
&eye_poses[i], //
1000
+
&fovs[i], //
1001
+
rsci->image, // squash_image
1002
+
rsci_rtr, // squash_rtr
1003
+
&layer_viewport_data); // squash_viewport_data
1004
+
1005
+
comp_render_gfx_add_target_view( //
1006
+
&data, //
1007
+
sample_view, // squash_as_src_sample_view
1008
+
&layer_norm_rect, // squash_as_src_norm_rect
1009
+
&vertex_rots[i], // target_vertex_rot
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
+
1019
+
// Add the target info.
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
-
comp_render_cs_initial_init( //
1087
-
&data, // data
1088
-
target_image, // target_image
1089
-
target_image_view, // target_unorm_view
1090
-
fast_path, // fast_path
1091
-
do_timewarp); // do_timewarp
1092
+
comp_render_initial_init( //
1093
+
&data, // data
1094
+
fast_path, // fast_path
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
-
comp_render_cs_add_view( //
1118
-
&data, //
1119
-
&world_poses[i], //
1120
-
&eye_poses[i], //
1121
-
&fovs[i], //
1122
-
rsci->image, // squash_image
1123
-
storage_view, // squash_storage_view
1124
-
&layer_viewport_data, // squash_viewport_data
1125
-
sample_view, // squash_as_src_sample_view
1126
-
&layer_norm_rect, // squash_as_src_norm_rect
1127
-
&views[i]); // target_viewport_data
1121
+
comp_render_cs_add_squash_view( //
1122
+
&data, //
1123
+
&world_poses[i], //
1124
+
&eye_poses[i], //
1125
+
&fovs[i], //
1126
+
rsci->image, // squash_image
1127
+
storage_view, // squash_storage_view
1128
+
&layer_viewport_data); // squash_viewport_data
1129
+
1130
+
comp_render_cs_add_target_view( //
1131
+
&data, //
1132
+
sample_view, // squash_as_src_sample_view
1133
+
&layer_norm_rect, // squash_as_src_norm_rect
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
+
1143
+
// Add the target info.
1144
+
comp_render_cs_add_target( //
1145
+
&data, // data
1146
+
target_image, // target_image
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
+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
-
//! The number of views currently in this dispatch data.
168
-
uint32_t view_count;
167
+
/*!
168
+
* The number of squash views currently in this dispatch data.
169
+
*/
170
+
uint32_t squash_view_count;
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
+
//! Has this struct been setup to use the target.
182
+
bool initialized;
183
+
184
+
/*!
185
+
* The number of target views currently, when calling dispatch
186
+
* this has to be either zero or the same number as
187
+
* squash_view_count, see also the target.initialized field.
188
+
*/
189
+
uint32_t view_count;
190
+
178
191
//! Members used only by GFX @ref comp_render_gfx
179
192
struct
180
193
{
···
195
208
};
196
209
197
210
/*!
211
+
* Initialize structure for use without the target step.
212
+
*
213
+
* @param[out] data Common render dispatch data. Will be zeroed and initialized.
214
+
* @param fast_path Whether we will use the "fast path" avoiding layer squashing.
215
+
* @param do_timewarp Whether timewarp (reprojection) will be performed.
216
+
*/
217
+
static inline void
218
+
comp_render_initial_init(struct comp_render_dispatch_data *data, bool fast_path, bool do_timewarp)
219
+
{
220
+
U_ZERO(data);
221
+
222
+
data->fast_path = fast_path;
223
+
data->do_timewarp = do_timewarp;
224
+
}
225
+
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
-
comp_render_dispatch_add_view(struct comp_render_dispatch_data *data,
224
-
const struct xrt_pose *world_pose,
225
-
const struct xrt_pose *eye_pose,
226
-
const struct xrt_fov *fov,
227
-
VkImage squash_image,
228
-
const struct render_viewport_data *squash_viewport_data,
229
-
VkImageView squash_as_src_sample_view,
230
-
const struct xrt_normalized_rect *squash_as_src_norm_rect,
231
-
const struct render_viewport_data *target_viewport_data)
252
+
comp_render_dispatch_add_squash_view(struct comp_render_dispatch_data *data,
253
+
const struct xrt_pose *world_pose,
254
+
const struct xrt_pose *eye_pose,
255
+
const struct xrt_fov *fov,
256
+
VkImage squash_image,
257
+
const struct render_viewport_data *squash_viewport_data)
232
258
{
233
-
uint32_t i = data->view_count++;
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
+
return view;
277
+
}
278
+
279
+
static inline struct comp_render_view_data *
280
+
comp_render_dispatch_add_target_view(struct comp_render_dispatch_data *data,
281
+
VkImageView squash_as_src_sample_view,
282
+
const struct xrt_normalized_rect *squash_as_src_norm_rect,
283
+
const struct render_viewport_data *target_viewport_data)
284
+
{
285
+
uint32_t i = data->target.view_count++;
286
+
287
+
assert(i < data->squash_view_count);
288
+
assert(i < ARRAY_SIZE(data->views));
289
+
290
+
struct comp_render_view_data *view = &data->views[i];
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
-
* @param[out] data Common render dispatch data. Will be zeroed and initialized.
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
-
* @param fast_path Whether we will use the "fast path" avoiding layer squashing.
287
-
* @param do_timewarp Whether timewarp (reprojection) will be performed.
288
328
*/
289
329
static inline void
290
-
comp_render_gfx_initial_init(struct comp_render_dispatch_data *data,
291
-
struct render_gfx_target_resources *target_rtr,
292
-
bool fast_path,
293
-
bool do_timewarp)
330
+
comp_render_gfx_add_target(struct comp_render_dispatch_data *data, struct render_gfx_target_resources *target_rtr)
294
331
{
295
-
U_ZERO(data);
296
-
297
-
data->fast_path = fast_path;
298
-
data->do_timewarp = do_timewarp;
332
+
// Error tracking.
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
-
comp_render_gfx_add_view(struct comp_render_dispatch_data *data,
331
-
const struct xrt_pose *world_pose,
332
-
const struct xrt_pose *eye_pose,
333
-
const struct xrt_fov *fov,
334
-
VkImage squash_image,
335
-
struct render_gfx_target_resources *squash_rtr,
336
-
const struct render_viewport_data *layer_viewport_data,
337
-
VkImageView squash_as_src_sample_view,
338
-
const struct xrt_normalized_rect *squash_as_src_norm_rect,
339
-
const struct xrt_matrix_2x2 *target_vertex_rot,
340
-
const struct render_viewport_data *target_viewport_data)
365
+
comp_render_gfx_add_squash_view(struct comp_render_dispatch_data *data,
366
+
const struct xrt_pose *world_pose,
367
+
const struct xrt_pose *eye_pose,
368
+
const struct xrt_fov *fov,
369
+
VkImage squash_image,
370
+
struct render_gfx_target_resources *squash_rtr,
371
+
const struct render_viewport_data *layer_viewport_data)
341
372
{
342
-
struct comp_render_view_data *view = comp_render_dispatch_add_view( //
343
-
data, //
344
-
world_pose, //
345
-
eye_pose, //
346
-
fov, //
347
-
squash_image, //
348
-
layer_viewport_data, //
349
-
squash_as_src_sample_view, //
350
-
squash_as_src_norm_rect, //
351
-
target_viewport_data);
373
+
struct comp_render_view_data *view = comp_render_dispatch_add_squash_view( //
374
+
data, //
375
+
world_pose, //
376
+
eye_pose, //
377
+
fov, //
378
+
squash_image, //
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
+
}
384
+
385
+
static inline void
386
+
comp_render_gfx_add_target_view(struct comp_render_dispatch_data *data,
387
+
VkImageView squash_as_src_sample_view,
388
+
const struct xrt_normalized_rect *squash_as_src_norm_rect,
389
+
const struct xrt_matrix_2x2 *target_vertex_rot,
390
+
const struct render_viewport_data *target_viewport_data)
391
+
{
392
+
struct comp_render_view_data *view = comp_render_dispatch_add_target_view( //
393
+
data, //
394
+
squash_as_src_sample_view, //
395
+
squash_as_src_norm_rect, //
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
-
* Initialize structure for use of the CS renderer.
499
+
* Add the target info, as required by the CS renderer.
458
500
*
459
-
* @param data Common render dispatch data. Will be zeroed and initialized.
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
-
* @param fast_path Whether we will use the "fast path" avoiding layer squashing.
463
-
* @param do_timewarp Whether timewarp (reprojection) will be performed.
464
504
*/
465
505
static inline void
466
-
comp_render_cs_initial_init(struct comp_render_dispatch_data *data,
467
-
VkImage target_image,
468
-
VkImageView target_storage_view,
469
-
bool fast_path,
470
-
bool do_timewarp)
506
+
comp_render_cs_add_target(struct comp_render_dispatch_data *data, VkImage target_image, VkImageView target_storage_view)
471
507
{
472
-
U_ZERO(data);
473
-
474
-
data->fast_path = fast_path;
475
-
data->do_timewarp = do_timewarp;
508
+
// Error tracking.
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
-
comp_render_cs_add_view(struct comp_render_dispatch_data *data,
506
-
const struct xrt_pose *world_pose,
507
-
const struct xrt_pose *eye_pose,
508
-
const struct xrt_fov *fov,
509
-
VkImage squash_image,
510
-
VkImageView squash_storage_view,
511
-
const struct render_viewport_data *squash_viewport_data,
512
-
VkImageView squash_as_src_sample_view,
513
-
const struct xrt_normalized_rect *squash_as_src_norm_rect,
514
-
const struct render_viewport_data *target_viewport_data)
539
+
comp_render_cs_add_squash_view(struct comp_render_dispatch_data *data,
540
+
const struct xrt_pose *world_pose,
541
+
const struct xrt_pose *eye_pose,
542
+
const struct xrt_fov *fov,
543
+
VkImage squash_image,
544
+
VkImageView squash_storage_view,
545
+
const struct render_viewport_data *squash_viewport_data)
515
546
{
516
-
struct comp_render_view_data *view = comp_render_dispatch_add_view( //
517
-
data, //
518
-
world_pose, //
519
-
eye_pose, //
520
-
fov, //
521
-
squash_image, //
522
-
squash_viewport_data, //
523
-
squash_as_src_sample_view, //
524
-
squash_as_src_norm_rect, //
525
-
target_viewport_data); //
547
+
struct comp_render_view_data *view = comp_render_dispatch_add_squash_view( //
548
+
data, //
549
+
world_pose, //
550
+
eye_pose, //
551
+
fov, //
552
+
squash_image, //
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
+
}
558
+
559
+
static inline void
560
+
comp_render_cs_add_target_view(struct comp_render_dispatch_data *data,
561
+
VkImageView squash_as_src_sample_view,
562
+
const struct xrt_normalized_rect *squash_as_src_norm_rect,
563
+
const struct render_viewport_data *target_viewport_data)
564
+
{
565
+
struct comp_render_view_data *view = comp_render_dispatch_add_target_view( //
566
+
data, //
567
+
squash_as_src_sample_view, //
568
+
squash_as_src_norm_rect, //
569
+
target_viewport_data); //
570
+
(void)view;
529
571
}
530
572
531
573
/*!
+18
-12
src/xrt/compositor/util/comp_render_cs.c
+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
-
if (d->view_count > XRT_MAX_VIEWS) {
335
+
if (d->target.view_count > XRT_MAX_VIEWS) {
336
336
U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS);
337
-
assert(d->view_count < XRT_MAX_VIEWS);
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
-
for (uint32_t i = 0; i < d->view_count; ++i) {
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
-
if (d->view_count > XRT_MAX_VIEWS) {
364
+
if (d->target.view_count > XRT_MAX_VIEWS) {
365
365
U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS);
366
-
assert(d->view_count < XRT_MAX_VIEWS);
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
-
for (uint32_t i = 0; i < d->view_count; i++) {
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
-
if (d->view_count > XRT_MAX_VIEWS) {
412
+
if (d->target.view_count > XRT_MAX_VIEWS) {
413
413
U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS);
414
-
assert(d->view_count < XRT_MAX_VIEWS);
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
-
for (uint32_t i = 0; i < d->view_count; i++) {
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
-
for (uint32_t view_index = 0; view_index < d->view_count; view_index++) {
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
+
if (!d->target.initialized) {
723
+
VK_ERROR(render->r->vk, "Target hasn't been initialized, not rendering anything.");
724
+
assert(d->target.initialized);
725
+
return;
726
+
}
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
-
for (uint32_t view = 0; view < d->view_count; ++view) {
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
-
for (uint32_t view = 0; view < d->view_count; ++view) {
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
+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
-
for (uint32_t i = 0; i < d->view_count; i++) {
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
-
for (uint32_t i = 0; i < d->view_count; i++) {
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
-
for (uint32_t i = 0; i < d->view_count; i++) {
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
-
for (uint32_t i = 0; i < d->view_count; i++) {
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
-
for (uint32_t view = 0; view < d->view_count; view++) {
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
-
for (uint32_t view = 0; view < d->view_count; view++) {
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
-
for (uint32_t view = 0; view < d->view_count; view++) {
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
+
if (!d->target.initialized) {
890
+
VK_ERROR(render->r->vk, "Target hasn't been initialized, not rendering anything.");
891
+
assert(d->target.initialized);
892
+
return;
893
+
}
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
-
for (uint32_t view = 0; view < d->view_count; ++view) {
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
-
for (uint32_t view = 0; view < d->view_count; ++view) {
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
+1
-1
src/xrt/compositor/util/comp_render_helpers.h