The open source OpenXR runtime
c+ipc+st: Complete equirect1 boilerplate.
authored by
Lubosz Sarnecki
and committed by
Jakob Bornecrantz
dc45a201
c8bdfae8
+237
-5
+20
src/xrt/compositor/client/comp_gl_client.c
+20
src/xrt/compositor/client/comp_gl_client.c
···
263
263
}
264
264
265
265
static xrt_result_t
266
+
client_gl_compositor_layer_equirect1(struct xrt_compositor *xc,
267
+
struct xrt_device *xdev,
268
+
struct xrt_swapchain *xsc,
269
+
const struct xrt_layer_data *data)
270
+
{
271
+
struct client_gl_compositor *c = client_gl_compositor(xc);
272
+
struct xrt_swapchain *xscfb;
273
+
274
+
assert(data->type == XRT_LAYER_EQUIRECT1);
275
+
276
+
xscfb = &client_gl_swapchain(xsc)->xscn->base;
277
+
278
+
struct xrt_layer_data d = *data;
279
+
d.flip_y = !d.flip_y;
280
+
281
+
return xrt_comp_layer_equirect1(&c->xcn->base, xdev, xscfb, &d);
282
+
}
283
+
284
+
static xrt_result_t
266
285
client_gl_compositor_layer_equirect2(struct xrt_compositor *xc,
267
286
struct xrt_device *xdev,
268
287
struct xrt_swapchain *xsc,
···
442
461
c->base.base.layer_quad = client_gl_compositor_layer_quad;
443
462
c->base.base.layer_cube = client_gl_compositor_layer_cube;
444
463
c->base.base.layer_cylinder = client_gl_compositor_layer_cylinder;
464
+
c->base.base.layer_equirect1 = client_gl_compositor_layer_equirect1;
445
465
c->base.base.layer_equirect2 = client_gl_compositor_layer_equirect2;
446
466
c->base.base.layer_commit = client_gl_compositor_layer_commit;
447
467
c->base.base.destroy = client_gl_compositor_destroy;
+17
src/xrt/compositor/client/comp_vk_client.c
+17
src/xrt/compositor/client/comp_vk_client.c
···
330
330
}
331
331
332
332
static xrt_result_t
333
+
client_vk_compositor_layer_equirect1(struct xrt_compositor *xc,
334
+
struct xrt_device *xdev,
335
+
struct xrt_swapchain *xsc,
336
+
const struct xrt_layer_data *data)
337
+
{
338
+
struct client_vk_compositor *c = client_vk_compositor(xc);
339
+
struct xrt_swapchain *xscfb;
340
+
341
+
assert(data->type == XRT_LAYER_EQUIRECT1);
342
+
343
+
xscfb = &client_vk_swapchain(xsc)->xscn->base;
344
+
345
+
return xrt_comp_layer_equirect1(&c->xcn->base, xdev, xscfb, data);
346
+
}
347
+
348
+
static xrt_result_t
333
349
client_vk_compositor_layer_equirect2(struct xrt_compositor *xc,
334
350
struct xrt_device *xdev,
335
351
struct xrt_swapchain *xsc,
···
541
557
c->base.base.layer_quad = client_vk_compositor_layer_quad;
542
558
c->base.base.layer_cube = client_vk_compositor_layer_cube;
543
559
c->base.base.layer_cylinder = client_vk_compositor_layer_cylinder;
560
+
c->base.base.layer_equirect1 = client_vk_compositor_layer_equirect1;
544
561
c->base.base.layer_equirect2 = client_vk_compositor_layer_equirect2;
545
562
c->base.base.layer_commit = client_vk_compositor_layer_commit;
546
563
c->base.base.destroy = client_vk_compositor_destroy;
+17
src/xrt/compositor/main/comp_compositor.c
+17
src/xrt/compositor/main/comp_compositor.c
···
441
441
}
442
442
443
443
static xrt_result_t
444
+
compositor_layer_equirect1(struct xrt_compositor *xc,
445
+
struct xrt_device *xdev,
446
+
struct xrt_swapchain *xsc,
447
+
const struct xrt_layer_data *data)
448
+
{
449
+
return do_single(xc, xdev, xsc, data);
450
+
}
451
+
452
+
static xrt_result_t
444
453
compositor_layer_equirect2(struct xrt_compositor *xc,
445
454
struct xrt_device *xdev,
446
455
struct xrt_swapchain *xsc,
···
512
521
struct comp_swapchain_image *image;
513
522
image = &layer->scs[0]->images[cyl->sub.image_index];
514
523
comp_renderer_set_cylinder_layer(c->r, i, image, data);
524
+
} break;
525
+
case XRT_LAYER_EQUIRECT1: {
526
+
struct xrt_layer_equirect1_data *eq =
527
+
&layer->data.equirect1;
528
+
struct comp_swapchain_image *image;
529
+
image = &layer->scs[0]->images[eq->sub.image_index];
530
+
comp_renderer_set_equirect1_layer(c->r, i, image, data);
515
531
} break;
516
532
case XRT_LAYER_EQUIRECT2: {
517
533
struct xrt_layer_equirect2_data *eq =
···
1308
1324
c->base.base.layer_quad = compositor_layer_quad;
1309
1325
c->base.base.layer_cube = compositor_layer_cube;
1310
1326
c->base.base.layer_cylinder = compositor_layer_cylinder;
1327
+
c->base.base.layer_equirect1 = compositor_layer_equirect1;
1311
1328
c->base.base.layer_equirect2 = compositor_layer_equirect2;
1312
1329
c->base.base.layer_commit = compositor_layer_commit;
1313
1330
c->base.base.poll_events = compositor_poll_events;
+1
src/xrt/compositor/main/comp_layer.c
+1
src/xrt/compositor/main/comp_layer.c
+36
src/xrt/compositor/main/comp_renderer.c
+36
src/xrt/compositor/main/comp_renderer.c
···
575
575
}
576
576
577
577
void
578
+
comp_renderer_set_equirect1_layer(struct comp_renderer *r,
579
+
uint32_t layer,
580
+
struct comp_swapchain_image *image,
581
+
struct xrt_layer_data *data)
582
+
{
583
+
584
+
struct xrt_vec3 s = {1.0f, 1.0f, 1.0f};
585
+
struct xrt_matrix_4x4 model_matrix;
586
+
math_matrix_4x4_model(&data->equirect1.pose, &s, &model_matrix);
587
+
588
+
comp_layer_set_flip_y(r->lr->layers[layer], data->flip_y);
589
+
590
+
struct comp_render_layer *l = r->lr->layers[layer];
591
+
l->type = XRT_LAYER_EQUIRECT1;
592
+
l->visibility = data->equirect1.visibility;
593
+
l->flags = data->flags;
594
+
l->view_space =
595
+
(data->flags & XRT_LAYER_COMPOSITION_VIEW_SPACE_BIT) != 0;
596
+
l->transformation_ubo_binding = r->lr->transformation_ubo_binding;
597
+
l->texture_binding = r->lr->texture_binding;
598
+
599
+
comp_layer_update_descriptors(
600
+
l, image->repeat_sampler,
601
+
get_image_view(image, data->flags,
602
+
data->equirect1.sub.array_index));
603
+
604
+
// TODO!
605
+
// comp_layer_update_equirect1_descriptor(l, &data->equirect1);
606
+
607
+
for (uint32_t i = 0; i < 2; i++) {
608
+
l->transformation[i].offset = data->equirect1.sub.rect.offset;
609
+
l->transformation[i].extent = data->equirect1.sub.rect.extent;
610
+
}
611
+
}
612
+
613
+
void
578
614
comp_renderer_set_equirect2_layer(struct comp_renderer *r,
579
615
uint32_t layer,
580
616
struct comp_swapchain_image *image,
+6
src/xrt/compositor/main/comp_renderer.h
+6
src/xrt/compositor/main/comp_renderer.h
···
74
74
struct xrt_layer_data *data);
75
75
76
76
void
77
+
comp_renderer_set_equirect1_layer(struct comp_renderer *r,
78
+
uint32_t layer,
79
+
struct comp_swapchain_image *image,
80
+
struct xrt_layer_data *data);
81
+
82
+
void
77
83
comp_renderer_set_equirect2_layer(struct comp_renderer *r,
78
84
uint32_t layer,
79
85
struct comp_swapchain_image *image,
+51
src/xrt/include/xrt/xrt_compositor.h
+51
src/xrt/include/xrt/xrt_compositor.h
···
96
96
XRT_LAYER_QUAD,
97
97
XRT_LAYER_CUBE,
98
98
XRT_LAYER_CYLINDER,
99
+
XRT_LAYER_EQUIRECT1,
99
100
XRT_LAYER_EQUIRECT2,
100
101
};
101
102
···
250
251
};
251
252
252
253
/*!
254
+
* All the pure data values associated with a equirect1 layer.
255
+
*
256
+
* The @ref xrt_swapchain references and @ref xrt_device are provided outside of
257
+
* this struct.
258
+
*/
259
+
struct xrt_layer_equirect1_data
260
+
{
261
+
enum xrt_layer_eye_visibility visibility;
262
+
263
+
struct xrt_sub_image sub;
264
+
265
+
struct xrt_pose pose;
266
+
float radius;
267
+
struct xrt_vec2 scale;
268
+
struct xrt_vec2 bias;
269
+
};
270
+
271
+
/*!
253
272
* All the pure data values associated with a equirect2 layer.
254
273
*
255
274
* The @ref xrt_swapchain references and @ref xrt_device are provided outside of
···
327
346
struct xrt_layer_quad_data quad;
328
347
struct xrt_layer_cube_data cube;
329
348
struct xrt_layer_cylinder_data cylinder;
349
+
struct xrt_layer_equirect1_data equirect1;
330
350
struct xrt_layer_equirect2_data equirect2;
331
351
};
332
352
};
···
723
743
const struct xrt_layer_data *data);
724
744
725
745
/*!
746
+
* Adds a equirect1 layer for submission.
747
+
*
748
+
* @param xc Self pointer
749
+
* @param xdev The device the layer is relative to.
750
+
* @param xsc Swapchain.
751
+
* @param data All of the pure data bits.
752
+
*/
753
+
xrt_result_t (*layer_equirect1)(struct xrt_compositor *xc,
754
+
struct xrt_device *xdev,
755
+
struct xrt_swapchain *xsc,
756
+
const struct xrt_layer_data *data);
757
+
758
+
759
+
/*!
726
760
* Adds a equirect2 layer for submission.
727
761
*
728
762
* @param xc Self pointer
···
979
1013
const struct xrt_layer_data *data)
980
1014
{
981
1015
return xc->layer_cylinder(xc, xdev, xsc, data);
1016
+
}
1017
+
1018
+
1019
+
/*!
1020
+
* @copydoc xrt_compositor::layer_equirect1
1021
+
*
1022
+
* Helper for calling through the function pointer.
1023
+
*
1024
+
* @public @memberof xrt_compositor
1025
+
*/
1026
+
static inline xrt_result_t
1027
+
xrt_comp_layer_equirect1(struct xrt_compositor *xc,
1028
+
struct xrt_device *xdev,
1029
+
struct xrt_swapchain *xsc,
1030
+
const struct xrt_layer_data *data)
1031
+
{
1032
+
return xc->layer_equirect1(xc, xdev, xsc, data);
982
1033
}
983
1034
984
1035
/*!
+10
src/xrt/ipc/client/ipc_client_compositor.c
+10
src/xrt/ipc/client/ipc_client_compositor.c
···
592
592
}
593
593
594
594
static xrt_result_t
595
+
ipc_compositor_layer_equirect1(struct xrt_compositor *xc,
596
+
struct xrt_device *xdev,
597
+
struct xrt_swapchain *xsc,
598
+
const struct xrt_layer_data *data)
599
+
{
600
+
return handle_layer(xc, xdev, xsc, data, XRT_LAYER_EQUIRECT1);
601
+
}
602
+
603
+
static xrt_result_t
595
604
ipc_compositor_layer_equirect2(struct xrt_compositor *xc,
596
605
struct xrt_device *xdev,
597
606
struct xrt_swapchain *xsc,
···
785
794
c->base.base.layer_quad = ipc_compositor_layer_quad;
786
795
c->base.base.layer_cube = ipc_compositor_layer_cube;
787
796
c->base.base.layer_cylinder = ipc_compositor_layer_cylinder;
797
+
c->base.base.layer_equirect1 = ipc_compositor_layer_equirect1;
788
798
c->base.base.layer_equirect2 = ipc_compositor_layer_equirect2;
789
799
c->base.base.layer_commit = ipc_compositor_layer_commit;
790
800
c->base.base.destroy = ipc_compositor_destroy;
+1
src/xrt/ipc/server/ipc_server_per_client_thread.c
+1
src/xrt/ipc/server/ipc_server_per_client_thread.c
+25
src/xrt/ipc/server/ipc_server_process.c
+25
src/xrt/ipc/server/ipc_server_process.c
···
869
869
}
870
870
871
871
static bool
872
+
_update_equirect1_layer(struct xrt_compositor *xc,
873
+
volatile struct ipc_client_state *ics,
874
+
volatile struct ipc_layer_entry *layer,
875
+
uint32_t i)
876
+
{
877
+
struct xrt_device *xdev;
878
+
struct xrt_swapchain *xcs;
879
+
struct xrt_layer_data *data;
880
+
881
+
if (!do_single(xc, ics, layer, i, "equirect1", &xdev, &xcs, &data)) {
882
+
return false;
883
+
}
884
+
885
+
xrt_comp_layer_equirect1(xc, xdev, xcs, data);
886
+
887
+
return true;
888
+
}
889
+
890
+
static bool
872
891
_update_equirect2_layer(struct xrt_compositor *xc,
873
892
volatile struct ipc_client_state *ics,
874
893
volatile struct ipc_layer_entry *layer,
···
971
990
case XRT_LAYER_CYLINDER:
972
991
if (!_update_cylinder_layer(xc, ics, layer,
973
992
i)) {
993
+
return false;
994
+
}
995
+
break;
996
+
case XRT_LAYER_EQUIRECT1:
997
+
if (!_update_equirect1_layer(xc, ics, layer,
998
+
i)) {
974
999
return false;
975
1000
}
976
1001
break;
+3
src/xrt/state_trackers/oxr/oxr_instance.c
+3
src/xrt/state_trackers/oxr/oxr_instance.c
···
353
353
CHECK_LAYER_TYPE("projection layers with depth images",
354
354
layer_stereo_projection_depth);
355
355
#endif
356
+
#ifdef XRT_FEATURE_OPENXR_LAYER_EQUIRECT1
357
+
CHECK_LAYER_TYPE("equirect1 layers", layer_equirect1);
358
+
#endif
356
359
#ifdef XRT_FEATURE_OPENXR_LAYER_EQUIRECT2
357
360
CHECK_LAYER_TYPE("equirect2 layers", layer_equirect2);
358
361
#endif
+50
-5
src/xrt/state_trackers/oxr/oxr_session.c
+50
-5
src/xrt/state_trackers/oxr/oxr_session.c
···
1315
1315
layer_index, equirect->radius);
1316
1316
}
1317
1317
1318
-
//! @todo Not all fields validated.
1319
-
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE,
1320
-
"XrCompositionLayerEquirectKHR not implemented");
1318
+
return XR_SUCCESS;
1321
1319
#endif
1322
1320
}
1323
1321
···
1798
1796
return XR_SUCCESS;
1799
1797
}
1800
1798
1801
-
static void
1799
+
static XrResult
1802
1800
submit_equirect1_layer(struct oxr_session *sess,
1803
1801
struct xrt_compositor *xc,
1804
1802
struct oxr_logger *log,
···
1807
1805
struct xrt_pose *inv_offset,
1808
1806
uint64_t timestamp)
1809
1807
{
1810
-
// Not implemented
1808
+
struct oxr_swapchain *sc = XRT_CAST_OXR_HANDLE_TO_PTR(
1809
+
struct oxr_swapchain *, equirect->subImage.swapchain);
1810
+
struct oxr_space *spc =
1811
+
XRT_CAST_OXR_HANDLE_TO_PTR(struct oxr_space *, equirect->space);
1812
+
1813
+
enum xrt_layer_composition_flags flags =
1814
+
convert_layer_flags(equirect->layerFlags);
1815
+
1816
+
struct xrt_pose *pose_ptr = (struct xrt_pose *)&equirect->pose;
1817
+
1818
+
struct xrt_pose pose;
1819
+
if (!handle_space(log, sess, spc, pose_ptr, inv_offset, timestamp,
1820
+
&pose)) {
1821
+
return XR_SUCCESS;
1822
+
}
1823
+
1824
+
if (spc->is_reference && spc->type == XR_REFERENCE_SPACE_TYPE_VIEW) {
1825
+
flags |= XRT_LAYER_COMPOSITION_VIEW_SPACE_BIT;
1826
+
}
1827
+
1828
+
struct xrt_layer_data data;
1829
+
U_ZERO(&data);
1830
+
data.type = XRT_LAYER_EQUIRECT1;
1831
+
data.name = XRT_INPUT_GENERIC_HEAD_POSE;
1832
+
data.timestamp = timestamp;
1833
+
data.flags = flags;
1834
+
1835
+
struct xrt_rect *rect =
1836
+
(struct xrt_rect *)&equirect->subImage.imageRect;
1837
+
1838
+
data.equirect1.visibility =
1839
+
convert_eye_visibility(equirect->eyeVisibility);
1840
+
data.equirect1.sub.image_index = sc->released.index;
1841
+
data.equirect1.sub.array_index = equirect->subImage.imageArrayIndex;
1842
+
data.equirect1.sub.rect = *rect;
1843
+
data.equirect1.pose = pose;
1844
+
1845
+
data.equirect1.radius = equirect->radius;
1846
+
1847
+
struct xrt_vec2 *scale = (struct xrt_vec2 *)&equirect->scale;
1848
+
struct xrt_vec2 *bias = (struct xrt_vec2 *)&equirect->bias;
1849
+
1850
+
data.equirect1.scale = *scale;
1851
+
data.equirect1.bias = *bias;
1852
+
1853
+
CALL_CHK(xrt_comp_layer_equirect1(xc, head, sc->swapchain, &data));
1854
+
1855
+
return XR_SUCCESS;
1811
1856
}
1812
1857
1813
1858
static void