From 55e026245a3bf8867764e9cf836e47962449f8ee Mon Sep 17 00:00:00 2001 From: Jakob Bornecrantz <jakob@collabora.com> Date: Tue, 9 Jun 2020 19:02:04 +0100 Subject: [PATCH] xrt: Use new xrt_layer_data in layer functions --- src/xrt/compositor/client/comp_gl_client.c | 53 ++++------- src/xrt/compositor/client/comp_vk_client.c | 60 ++++-------- src/xrt/compositor/main/comp_compositor.c | 50 +--------- src/xrt/include/xrt/xrt_compositor.h | 102 +++------------------ src/xrt/ipc/ipc_client_compositor.c | 72 ++------------- src/xrt/state_trackers/oxr/oxr_session.c | 71 ++++++++++---- 6 files changed, 117 insertions(+), 291 deletions(-) diff --git a/src/xrt/compositor/client/comp_gl_client.c b/src/xrt/compositor/client/comp_gl_client.c index ec971fbc6..2374e0535 100644 --- a/src/xrt/compositor/client/comp_gl_client.c +++ b/src/xrt/compositor/client/comp_gl_client.c @@ -145,61 +145,40 @@ client_gl_compositor_layer_begin(struct xrt_compositor *xc, } static xrt_result_t -client_gl_compositor_layer_stereo_projection( - struct xrt_compositor *xc, - uint64_t timestamp, - struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - struct xrt_swapchain *l_sc, - uint32_t l_image_index, - struct xrt_rect *l_rect, - uint32_t l_array_index, - struct xrt_fov *l_fov, - struct xrt_pose *l_pose, - struct xrt_swapchain *r_sc, - uint32_t r_image_index, - struct xrt_rect *r_rect, - uint32_t r_array_index, - struct xrt_fov *r_fov, - struct xrt_pose *r_pose, - bool flip_y) +client_gl_compositor_layer_stereo_projection(struct xrt_compositor *xc, + struct xrt_device *xdev, + struct xrt_swapchain *l_sc, + struct xrt_swapchain *r_sc, + struct xrt_layer_data *data) { struct client_gl_compositor *c = client_gl_compositor(xc); struct xrt_swapchain *l_xscfd, *r_xscfd; + assert(data->type == XRT_LAYER_STEREO_PROJECTION); + l_xscfd = &client_gl_swapchain(l_sc)->xscfd->base; r_xscfd = &client_gl_swapchain(r_sc)->xscfd->base; + data->flip_y = true; - return xrt_comp_layer_stereo_projection( - &c->xcfd->base, timestamp, xdev, name, layer_flags, l_xscfd, - l_image_index, l_rect, l_array_index, l_fov, l_pose, r_xscfd, - r_image_index, r_rect, r_array_index, r_fov, r_pose, true); + return xrt_comp_layer_stereo_projection(&c->xcfd->base, xdev, l_xscfd, + r_xscfd, data); } static xrt_result_t client_gl_compositor_layer_quad(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - enum xrt_layer_eye_visibility visibility, struct xrt_swapchain *sc, - uint32_t image_index, - struct xrt_rect *rect, - uint32_t array_index, - struct xrt_pose *pose, - struct xrt_vec2 *size, - bool flip_y) + struct xrt_layer_data *data) { struct client_gl_compositor *c = client_gl_compositor(xc); struct xrt_swapchain *xscfb; - xscfb = &client_gl_swapchain(sc)->xscfd->base; + assert(data->type == XRT_LAYER_QUAD); - return xrt_comp_layer_quad(&c->xcfd->base, timestamp, xdev, name, - layer_flags, visibility, xscfb, image_index, - rect, array_index, pose, size, true); + xscfb = &client_gl_swapchain(sc)->xscfd->base; + data->flip_y = true; + + return xrt_comp_layer_quad(&c->xcfd->base, xdev, xscfb, data); } static xrt_result_t diff --git a/src/xrt/compositor/client/comp_vk_client.c b/src/xrt/compositor/client/comp_vk_client.c index 77ef8d301..c77e4e1d1 100644 --- a/src/xrt/compositor/client/comp_vk_client.c +++ b/src/xrt/compositor/client/comp_vk_client.c @@ -8,13 +8,14 @@ * @ingroup comp_client */ -#include <stdio.h> -#include <stdlib.h> - #include "util/u_misc.h" #include "comp_vk_client.h" +#include <stdio.h> +#include <stdlib.h> +#include <assert.h> + /*! * Down-cast helper. * @@ -174,61 +175,40 @@ client_vk_compositor_layer_begin(struct xrt_compositor *xc, } static xrt_result_t -client_vk_compositor_layer_stereo_projection( - struct xrt_compositor *xc, - uint64_t timestamp, - struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - struct xrt_swapchain *l_sc, - uint32_t l_image_index, - struct xrt_rect *l_rect, - uint32_t l_array_index, - struct xrt_fov *l_fov, - struct xrt_pose *l_pose, - struct xrt_swapchain *r_sc, - uint32_t r_image_index, - struct xrt_rect *r_rect, - uint32_t r_array_index, - struct xrt_fov *r_fov, - struct xrt_pose *r_pose, - bool flip_y) +client_vk_compositor_layer_stereo_projection(struct xrt_compositor *xc, + struct xrt_device *xdev, + struct xrt_swapchain *l_sc, + struct xrt_swapchain *r_sc, + struct xrt_layer_data *data) { struct client_vk_compositor *c = client_vk_compositor(xc); struct xrt_swapchain *l_xscfd, *r_xscfd; + assert(data->type == XRT_LAYER_STEREO_PROJECTION); + l_xscfd = &client_vk_swapchain(l_sc)->xscfd->base; r_xscfd = &client_vk_swapchain(r_sc)->xscfd->base; + data->flip_y = false; - return xrt_comp_layer_stereo_projection( - &c->xcfd->base, timestamp, xdev, name, layer_flags, l_xscfd, - l_image_index, l_rect, l_array_index, l_fov, l_pose, r_xscfd, - r_image_index, r_rect, r_array_index, r_fov, r_pose, false); + return xrt_comp_layer_stereo_projection(&c->xcfd->base, xdev, l_xscfd, + r_xscfd, data); } static xrt_result_t client_vk_compositor_layer_quad(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - enum xrt_layer_eye_visibility visibility, struct xrt_swapchain *sc, - uint32_t image_index, - struct xrt_rect *rect, - uint32_t array_index, - struct xrt_pose *pose, - struct xrt_vec2 *size, - bool flip_y) + struct xrt_layer_data *data) { struct client_vk_compositor *c = client_vk_compositor(xc); struct xrt_swapchain *xscfb; - xscfb = &client_vk_swapchain(sc)->xscfd->base; + assert(data->type == XRT_LAYER_QUAD); - return xrt_comp_layer_quad(&c->xcfd->base, timestamp, xdev, name, - layer_flags, visibility, xscfb, image_index, - rect, array_index, pose, size, false); + xscfb = &client_vk_swapchain(sc)->xscfd->base; + data->flip_y = false; + + return xrt_comp_layer_quad(&c->xcfd->base, xdev, xscfb, data); } static xrt_result_t diff --git a/src/xrt/compositor/main/comp_compositor.c b/src/xrt/compositor/main/comp_compositor.c index efb68178d..fc0eac844 100644 --- a/src/xrt/compositor/main/comp_compositor.c +++ b/src/xrt/compositor/main/comp_compositor.c @@ -294,23 +294,10 @@ compositor_layer_begin(struct xrt_compositor *xc, static xrt_result_t compositor_layer_stereo_projection(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, struct xrt_swapchain *l_sc, - uint32_t l_image_index, - struct xrt_rect *l_rect, - uint32_t l_array_index, - struct xrt_fov *l_fov, - struct xrt_pose *l_pose, struct xrt_swapchain *r_sc, - uint32_t r_image_index, - struct xrt_rect *r_rect, - uint32_t r_array_index, - struct xrt_fov *r_fov, - struct xrt_pose *r_pose, - bool flip_y) + struct xrt_layer_data *data) { struct comp_compositor *c = comp_compositor(xc); @@ -319,18 +306,9 @@ compositor_layer_stereo_projection(struct xrt_compositor *xc, uint32_t layer_id = c->slots[slot_id].num_layers; struct comp_layer *layer = &c->slots[slot_id].layers[layer_id]; - struct xrt_layer_data *data = &layer->data; layer->scs[0] = comp_swapchain(l_sc); layer->scs[1] = comp_swapchain(r_sc); - - data->stereo.l.image_index = l_image_index; - data->stereo.l.array_index = l_array_index; - data->stereo.r.image_index = r_image_index; - data->stereo.r.array_index = r_array_index; - - data->flags = layer_flags; - data->flip_y = flip_y; - data->type = XRT_LAYER_STEREO_PROJECTION; + layer->data = *data; c->slots[slot_id].num_layers++; return XRT_SUCCESS; @@ -338,18 +316,9 @@ compositor_layer_stereo_projection(struct xrt_compositor *xc, static xrt_result_t compositor_layer_quad(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - enum xrt_layer_eye_visibility visibility, struct xrt_swapchain *sc, - uint32_t image_index, - struct xrt_rect *rect, - uint32_t array_index, - struct xrt_pose *pose, - struct xrt_vec2 *size, - bool flip_y) + struct xrt_layer_data *data) { struct comp_compositor *c = comp_compositor(xc); @@ -358,20 +327,9 @@ compositor_layer_quad(struct xrt_compositor *xc, uint32_t layer_id = c->slots[slot_id].num_layers; struct comp_layer *layer = &c->slots[slot_id].layers[layer_id]; - struct xrt_layer_data *data = &layer->data; layer->scs[0] = comp_swapchain(sc); layer->scs[1] = NULL; - - data->quad.visibility = visibility; - data->quad.image_index = image_index; - data->quad.rect = *rect; - data->quad.array_index = array_index; - data->quad.pose = *pose; - data->quad.size = *size; - - data->flags = layer_flags; - data->flip_y = flip_y; - data->type = XRT_LAYER_QUAD; + layer->data = *data; c->slots[slot_id].num_layers++; return XRT_SUCCESS; diff --git a/src/xrt/include/xrt/xrt_compositor.h b/src/xrt/include/xrt/xrt_compositor.h index 0f88717d4..879b2312a 100644 --- a/src/xrt/include/xrt/xrt_compositor.h +++ b/src/xrt/include/xrt/xrt_compositor.h @@ -360,75 +360,30 @@ struct xrt_compositor * Adds a stereo projection layer for submissions. * * @param xc Self pointer - * @param timestamp When should this layer be shown. - * @param xdev The device the layer is relative to. - * @param name Which pose this layer is relative to. - * @param layer_flags Flags for this layer, applied to both images. - * @param l_sc Left swapchain. - * @param l_image_index Left image index as return by acquire_image. - * @param l_rect Left subimage rect. - * @param l_array_index Left array index. - * @param l_fov Left fov the left projection rendered with. - * @param l_pose Left pose the left projection rendered with. - * @param r_sc Right swapchain. - * @param r_image_index Right image index as return by acquire_image. - * @param r_rect Right subimage rect. - * @param r_array_index Right array index. - * @param r_fov Right fov the left projection rendered with. - * @param r_pose Right pose the left projection rendered with. - * @param flip_y Flip Y texture coordinates. + * @param xdev The device the layer is relative to. + * @param l_sc Left swapchain. + * @param r_sc Right swapchain. + * @param data All of the pure data bits. */ - xrt_result_t (*layer_stereo_projection)( - struct xrt_compositor *xc, - uint64_t timestamp, - struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - struct xrt_swapchain *l_sc, - uint32_t l_image_index, - struct xrt_rect *l_rect, - uint32_t l_array_index, - struct xrt_fov *l_fov, - struct xrt_pose *l_pose, - struct xrt_swapchain *r_sc, - uint32_t r_image_index, - struct xrt_rect *r_rect, - uint32_t r_array_index, - struct xrt_fov *r_fov, - struct xrt_pose *r_pose, - bool flip_y); + xrt_result_t (*layer_stereo_projection)(struct xrt_compositor *xc, + struct xrt_device *xdev, + struct xrt_swapchain *l_sc, + struct xrt_swapchain *r_sc, + struct xrt_layer_data *data); /*! * Adds a quad layer for submission, the center of the quad is specified * by the pose and extends outwards from it. * * @param xc Self pointer - * @param timestamp When should this layer be shown. * @param xdev The device the layer is relative to. - * @param name Which pose this layer is relative to. - * @param layer_flags Flags for this layer. - * @param visibility Which views are is this layer visible in. * @param sc Swapchain. - * @param image_index Image index as return by acquire_image. - * @param rect Subimage rect. - * @param array_index Array index. - * @param pose Pose the left projection rendered with. - * @param size Size of the quad in meters. - * @param flip_y Flip Y texture coordinates. + * @param data All of the pure data bits. */ xrt_result_t (*layer_quad)(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - enum xrt_layer_eye_visibility visibility, struct xrt_swapchain *sc, - uint32_t image_index, - struct xrt_rect *rect, - uint32_t array_index, - struct xrt_pose *pose, - struct xrt_vec2 *size, - bool flip_y); + struct xrt_layer_data *data); /*! * Commits all of the submitted layers, it's from this on that the @@ -586,28 +541,12 @@ xrt_comp_layer_begin(struct xrt_compositor *xc, */ static inline xrt_result_t xrt_comp_layer_stereo_projection(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, struct xrt_swapchain *l_sc, - uint32_t l_image_index, - struct xrt_rect *l_rect, - uint32_t l_array_index, - struct xrt_fov *l_fov, - struct xrt_pose *l_pose, struct xrt_swapchain *r_sc, - uint32_t r_image_index, - struct xrt_rect *r_rect, - uint32_t r_array_index, - struct xrt_fov *r_fov, - struct xrt_pose *r_pose, - bool flip_y) + struct xrt_layer_data *data) { - return xc->layer_stereo_projection( - xc, timestamp, xdev, name, layer_flags, l_sc, l_image_index, l_rect, - l_array_index, l_fov, l_pose, r_sc, r_image_index, r_rect, - r_array_index, r_fov, r_pose, flip_y); + return xc->layer_stereo_projection(xc, xdev, l_sc, r_sc, data); } /*! @@ -619,22 +558,11 @@ xrt_comp_layer_stereo_projection(struct xrt_compositor *xc, */ static inline xrt_result_t xrt_comp_layer_quad(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - enum xrt_layer_eye_visibility visibility, struct xrt_swapchain *sc, - uint32_t image_index, - struct xrt_rect *rect, - uint32_t array_index, - struct xrt_pose *pose, - struct xrt_vec2 *size, - bool flip_y) + struct xrt_layer_data *data) { - return xc->layer_quad(xc, timestamp, xdev, name, layer_flags, - visibility, sc, image_index, rect, array_index, - pose, size, flip_y); + return xc->layer_quad(xc, xdev, sc, data); } /*! diff --git a/src/xrt/ipc/ipc_client_compositor.c b/src/xrt/ipc/ipc_client_compositor.c index 7270384ff..1f1267cb3 100644 --- a/src/xrt/ipc/ipc_client_compositor.c +++ b/src/xrt/ipc/ipc_client_compositor.c @@ -339,56 +339,24 @@ ipc_compositor_layer_begin(struct xrt_compositor *xc, } static xrt_result_t -ipc_compositor_layer_stereo_projection( - struct xrt_compositor *xc, - uint64_t timestamp, - struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - struct xrt_swapchain *l_sc, - uint32_t l_image_index, - struct xrt_rect *l_rect, - uint32_t l_array_index, - struct xrt_fov *l_fov, - struct xrt_pose *l_pose, - struct xrt_swapchain *r_sc, - uint32_t r_image_index, - struct xrt_rect *r_rect, - uint32_t r_array_index, - struct xrt_fov *r_fov, - struct xrt_pose *r_pose, - bool flip_y) +ipc_compositor_layer_stereo_projection(struct xrt_compositor *xc, + struct xrt_device *xdev, + struct xrt_swapchain *l_sc, + struct xrt_swapchain *r_sc, + struct xrt_layer_data *data) { struct ipc_client_compositor *icc = ipc_client_compositor(xc); struct ipc_shared_memory *ism = icc->ipc_c->ism; struct ipc_layer_slot *slot = &ism->slots[icc->layers.slot_id]; struct ipc_layer_entry *layer = &slot->layers[icc->layers.num_layers]; - struct xrt_layer_data *data = &layer->data; - struct xrt_layer_stereo_projection_data *stereo = &data->stereo; struct ipc_client_swapchain *l = ipc_client_swapchain(l_sc); struct ipc_client_swapchain *r = ipc_client_swapchain(r_sc); layer->xdev_id = 0; //! @todo Real id. layer->swapchain_ids[0] = l->id; layer->swapchain_ids[1] = r->id; - - data->type = XRT_LAYER_STEREO_PROJECTION; - data->name = name; - data->timestamp = timestamp; - data->flags = layer_flags; - data->flip_y = flip_y; - - stereo->l.image_index = l_image_index; - stereo->l.rect = *l_rect; - stereo->l.array_index = l_array_index; - stereo->l.fov = *l_fov; - stereo->l.pose = *l_pose; - stereo->r.image_index = r_image_index; - stereo->r.rect = *r_rect; - stereo->r.array_index = r_array_index; - stereo->r.fov = *r_fov; - stereo->r.pose = *r_pose; + layer->data = *data; // Increment the number of layers. icc->layers.num_layers++; @@ -398,43 +366,23 @@ ipc_compositor_layer_stereo_projection( static xrt_result_t ipc_compositor_layer_quad(struct xrt_compositor *xc, - uint64_t timestamp, struct xrt_device *xdev, - enum xrt_input_name name, - enum xrt_layer_composition_flags layer_flags, - enum xrt_layer_eye_visibility visibility, struct xrt_swapchain *sc, - uint32_t image_index, - struct xrt_rect *rect, - uint32_t array_index, - struct xrt_pose *pose, - struct xrt_vec2 *size, - bool flip_y) + struct xrt_layer_data *data) { struct ipc_client_compositor *icc = ipc_client_compositor(xc); struct ipc_shared_memory *ism = icc->ipc_c->ism; struct ipc_layer_slot *slot = &ism->slots[icc->layers.slot_id]; struct ipc_layer_entry *layer = &slot->layers[icc->layers.num_layers]; - struct xrt_layer_data *data = &layer->data; - struct xrt_layer_quad_data *quad = &data->quad; struct ipc_client_swapchain *ics = ipc_client_swapchain(sc); + assert(data->type == XRT_LAYER_QUAD); + layer->xdev_id = 0; //! @todo Real id. layer->swapchain_ids[0] = ics->id; layer->swapchain_ids[1] = -1; - - data->type = XRT_LAYER_QUAD; - data->name = name; - data->timestamp = timestamp; - data->flags = layer_flags; - data->flip_y = flip_y; - - quad->image_index = image_index; - quad->rect = *rect; - quad->array_index = array_index; - quad->pose = *pose; - quad->size = *size; + layer->data = *data; // Increment the number of layers. icc->layers.num_layers++; diff --git a/src/xrt/state_trackers/oxr/oxr_session.c b/src/xrt/state_trackers/oxr/oxr_session.c index 6d22df204..ea8c59ac5 100644 --- a/src/xrt/state_trackers/oxr/oxr_session.c +++ b/src/xrt/state_trackers/oxr/oxr_session.c @@ -736,15 +736,30 @@ submit_quad_layer(struct xrt_compositor *xc, struct oxr_swapchain *sc = XRT_CAST_OXR_HANDLE_TO_PTR( struct oxr_swapchain *, quad->subImage.swapchain); + enum xrt_layer_composition_flags flags = quad->layerFlags; + struct xrt_pose pose; math_pose_transform(inv_offset, (struct xrt_pose *)&quad->pose, &pose); - CALL_CHK(xrt_comp_layer_quad( - xc, timestamp, head, XRT_INPUT_GENERIC_HEAD_POSE, quad->layerFlags, - (enum xrt_layer_eye_visibility)quad->eyeVisibility, sc->swapchain, - sc->released.index, (struct xrt_rect *)&quad->subImage.imageRect, - quad->subImage.imageArrayIndex, &pose, - (struct xrt_vec2 *)&quad->size, false)); + struct xrt_layer_data data; + U_ZERO(&data); + data.type = XRT_LAYER_QUAD; + data.name = XRT_INPUT_GENERIC_HEAD_POSE; + data.timestamp = timestamp; + data.flags = flags; + + struct xrt_vec2 *size = (struct xrt_vec2 *)&quad->size; + struct xrt_rect *rect = (struct xrt_rect *)&quad->subImage.imageRect; + + data.quad.visibility = + (enum xrt_layer_eye_visibility)quad->eyeVisibility; + data.quad.image_index = sc->released.index; + data.quad.array_index = quad->subImage.imageArrayIndex; + data.quad.rect = *rect; + data.quad.pose = pose; + data.quad.size = *size; + + CALL_CHK(xrt_comp_layer_quad(xc, head, sc->swapchain, &data)); return XR_SUCCESS; } @@ -757,7 +772,7 @@ submit_projection_layer(struct xrt_compositor *xc, struct xrt_pose *inv_offset, uint64_t timestamp) { - enum xrt_layer_composition_flags flags = 0; + enum xrt_layer_composition_flags flags = proj->layerFlags; struct oxr_swapchain *scs[2]; uint32_t num_chains = ARRAY_SIZE(scs); @@ -773,18 +788,36 @@ submit_projection_layer(struct xrt_compositor *xc, math_pose_transform(inv_offset, (struct xrt_pose *)&proj->views[1].pose, &pose[1]); - CALL_CHK(xrt_comp_layer_stereo_projection( - xc, timestamp, head, XRT_INPUT_GENERIC_HEAD_POSE, flags, - scs[0]->swapchain, // Left - scs[0]->released.index, - (struct xrt_rect *)&proj->views[0].subImage.imageRect, - proj->views[0].subImage.imageArrayIndex, - (struct xrt_fov *)&proj->views[0].fov, &pose[0], - scs[1]->swapchain, // Right - scs[1]->released.index, - (struct xrt_rect *)&proj->views[1].subImage.imageRect, - proj->views[1].subImage.imageArrayIndex, - (struct xrt_fov *)&proj->views[1].fov, &pose[1], false)); + struct xrt_rect *l_rect = + (struct xrt_rect *)&proj->views[0].subImage.imageRect; + struct xrt_fov *l_fov = (struct xrt_fov *)&proj->views[0].fov; + struct xrt_rect *r_rect = + (struct xrt_rect *)&proj->views[1].subImage.imageRect; + struct xrt_fov *r_fov = (struct xrt_fov *)&proj->views[1].fov; + + struct xrt_layer_data data; + U_ZERO(&data); + data.type = XRT_LAYER_STEREO_PROJECTION; + data.name = XRT_INPUT_GENERIC_HEAD_POSE; + data.timestamp = timestamp; + data.flags = flags; + + data.stereo.l.image_index = scs[0]->released.index; + data.stereo.l.array_index = proj->views[0].subImage.imageArrayIndex; + data.stereo.l.rect = *l_rect; + data.stereo.l.fov = *l_fov; + data.stereo.l.pose = pose[0]; + + data.stereo.r.image_index = scs[1]->released.index; + data.stereo.r.array_index = proj->views[1].subImage.imageArrayIndex; + data.stereo.r.rect = *r_rect; + data.stereo.r.fov = *r_fov; + data.stereo.r.pose = pose[1]; + + CALL_CHK(xrt_comp_layer_stereo_projection(xc, head, + scs[0]->swapchain, // Left + scs[1]->swapchain, // Right + &data)); return XR_SUCCESS; }