From 9d448cfb09afca88c2abdf5bc03c0761afde457d Mon Sep 17 00:00:00 2001 From: Rylie Pavlik Date: Fri, 6 Dec 2024 17:00:07 -0600 Subject: [PATCH] c/util: More diff reduction between comp_render_{cs,gfx} Just comments, rearranging, and other non-functional changes. Part-of: --- src/xrt/compositor/util/comp_render.h | 18 +- src/xrt/compositor/util/comp_render_cs.c | 120 +++++++----- src/xrt/compositor/util/comp_render_gfx.c | 219 +++++++++++----------- 3 files changed, 194 insertions(+), 163 deletions(-) diff --git a/src/xrt/compositor/util/comp_render.h b/src/xrt/compositor/util/comp_render.h index 010345fc4..b60f7b58d 100644 --- a/src/xrt/compositor/util/comp_render.h +++ b/src/xrt/compositor/util/comp_render.h @@ -345,13 +345,13 @@ comp_render_gfx_add_view(struct comp_render_dispatch_data *data, * @note Swapchains in the @p layers must implement @ref comp_swapchain in * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! * - * @param rr GFX render object + * @param render GFX render object * @param[in] layers Layers to render, see note. * @param[in] layer_count Number of elements in @p layers array. * @param[in] d Common render dispatch data */ void -comp_render_gfx_dispatch(struct render_gfx *rr, +comp_render_gfx_dispatch(struct render_gfx *render, const struct comp_layer *layers, const uint32_t layer_count, const struct comp_render_dispatch_data *d); @@ -468,7 +468,7 @@ comp_render_cs_add_view(struct comp_render_dispatch_data *data, * @note Swapchains in the @p layers must implement @ref comp_swapchain in * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! * - * @param crc Compute renderer object + * @param render Compute renderer object * @param view_index Index of the view * @param layers Layers to render, see note. * @param layer_count Number of elements in @p layers array. @@ -481,7 +481,7 @@ comp_render_cs_add_view(struct comp_render_dispatch_data *data, * @param do_timewarp */ void -comp_render_cs_layer(struct render_compute *crc, +comp_render_cs_layer(struct render_compute *render, uint32_t view_index, const struct comp_layer *layers, const uint32_t layer_count, @@ -513,21 +513,21 @@ comp_render_cs_layer(struct render_compute *crc, * @note Swapchains in the @p layers must implement @ref comp_swapchain in * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! * - * @param crc Compute renderer object + * @param render Compute renderer object * @param[in] layers Layers to render, see note. * @param[in] layer_count Number of elements in @p layers array. * @param[in] d Common render dispatch data * @param[in] transition_to Desired image layout for target images */ void -comp_render_cs_layers(struct render_compute *crc, +comp_render_cs_layers(struct render_compute *render, const struct comp_layer *layers, const uint32_t layer_count, const struct comp_render_dispatch_data *d, VkImageLayout transition_to); /*! - * Write commands to @p crc to do a full composition with distortion. + * Write commands to @p render to do a full composition with distortion. * * Helper function that takes a set of layers, new device poses, a scratch * images and writes the needed commands to the @ref render_compute to do a full @@ -551,14 +551,14 @@ comp_render_cs_layers(struct render_compute *crc, * @note Swapchains in the @p layers must implement @ref comp_swapchain in * addition to just @ref xrt_swapchain, as this function downcasts to @ref comp_swapchain ! * - * @param crc Compute renderer object + * @param render Compute renderer object * @param[in] layers Layers to render, see note. * @param[in] layer_count Number of elements in @p layers array. * @param[in] d Common render dispatch data * */ void -comp_render_cs_dispatch(struct render_compute *crc, +comp_render_cs_dispatch(struct render_compute *render, const struct comp_layer *layers, const uint32_t layer_count, const struct comp_render_dispatch_data *d); diff --git a/src/xrt/compositor/util/comp_render_cs.c b/src/xrt/compositor/util/comp_render_cs.c index e6d788abf..12ba9793d 100644 --- a/src/xrt/compositor/util/comp_render_cs.c +++ b/src/xrt/compositor/util/comp_render_cs.c @@ -2,7 +2,7 @@ // SPDX-License-Identifier: BSL-1.0 /*! * @file - * @brief Compositor rendering code. + * @brief Compositor (compute shader) rendering code. * @author Jakob Bornecrantz * @author Christoph Haag * @author Fernando Velazquez Innella @@ -53,6 +53,7 @@ get_layer_depth_image(const struct comp_layer *layer, uint32_t swapchain_index, return &sc->images[image_index]; } +/// Data setup for a cylinder layer static inline void do_cs_cylinder_layer(const struct comp_layer *layer, const struct xrt_matrix_4x4 *eye_view_mat, @@ -117,6 +118,7 @@ do_cs_cylinder_layer(const struct comp_layer *layer, *out_cur_image = cur_image; } +/// Data setup for an "equirect2" layer static inline void do_cs_equirect2_layer(const struct comp_layer *layer, const struct xrt_matrix_4x4 *eye_view_mat, @@ -179,6 +181,7 @@ do_cs_equirect2_layer(const struct comp_layer *layer, *out_cur_image = cur_image; } +/// Data setup for a projection layer static inline void do_cs_projection_layer(const struct comp_layer *layer, const struct xrt_pose *world_pose, @@ -241,6 +244,7 @@ do_cs_projection_layer(const struct comp_layer *layer, *out_cur_image = cur_image; } +/// Data setup for a quad layer static inline void do_cs_quad_layer(const struct comp_layer *layer, const struct xrt_matrix_4x4 *eye_view_mat, @@ -266,6 +270,8 @@ do_cs_quad_layer(const struct comp_layer *layer, // Set the normalized post transform values. struct xrt_normalized_rect post_transform = XRT_STRUCT_INIT; + + // Used for Subimage and OpenGL flip. set_post_transform_rect( // layer_data, // data &q->sub.norm_rect, // src_norm_rect @@ -331,7 +337,7 @@ do_cs_quad_layer(const struct comp_layer *layer, */ static void -do_cs_clear(struct render_compute *crc, const struct comp_render_dispatch_data *d) +do_cs_clear(struct render_compute *render, const struct comp_render_dispatch_data *d) { if (d->view_count > XRT_MAX_VIEWS) { U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); @@ -346,21 +352,21 @@ do_cs_clear(struct render_compute *crc, const struct comp_render_dispatch_data * render_compute_clear( // - crc, // crc + render, // crc d->cs.target_image, // target_image d->cs.target_unorm_view, // target_image_view target_viewport_datas); // views } static void -do_cs_distortion_from_scratch(struct render_compute *crc, const struct comp_render_dispatch_data *d) +do_cs_distortion_from_scratch(struct render_compute *render, const struct comp_render_dispatch_data *d) { if (d->view_count > XRT_MAX_VIEWS) { U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); assert(d->view_count < XRT_MAX_VIEWS); return; } - VkSampler clamp_to_border_black = crc->r->samplers.clamp_to_border_black; + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; // Data to fill in. VkImageView src_image_views[XRT_MAX_VIEWS]; @@ -387,7 +393,7 @@ do_cs_distortion_from_scratch(struct render_compute *crc, const struct comp_rend } render_compute_projection( // - crc, // crc + render, // crc src_samplers, // src_samplers src_image_views, // src_image_views src_norm_rects, // src_rects @@ -397,10 +403,10 @@ do_cs_distortion_from_scratch(struct render_compute *crc, const struct comp_rend } static void -do_cs_distortion_for_layer(struct render_compute *crc, +do_cs_distortion_for_layer(struct render_compute *render, + const struct comp_render_dispatch_data *d, const struct comp_layer *layer, - const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS], - const struct comp_render_dispatch_data *d) + const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) { if (d->view_count > XRT_MAX_VIEWS) { U_LOG_E("Only supports max %d views!", XRT_MAX_VIEWS); @@ -411,7 +417,7 @@ do_cs_distortion_for_layer(struct render_compute *crc, // Fetch from this data. const struct xrt_layer_data *data = &layer->data; - VkSampler clamp_to_border_black = crc->r->samplers.clamp_to_border_black; + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; // Data to fill in. VkImageView src_image_views[XRT_MAX_VIEWS]; @@ -459,7 +465,7 @@ do_cs_distortion_for_layer(struct render_compute *crc, if (!d->do_timewarp) { render_compute_projection( // - crc, // + render, // src_samplers, // src_image_views, // src_norm_rects, // @@ -468,7 +474,7 @@ do_cs_distortion_for_layer(struct render_compute *crc, target_viewport_datas); // } else { render_compute_projection_timewarp( // - crc, // + render, // src_samplers, // src_image_views, // src_norm_rects, // @@ -489,7 +495,7 @@ do_cs_distortion_for_layer(struct render_compute *crc, */ void -comp_render_cs_layer(struct render_compute *crc, +comp_render_cs_layer(struct render_compute *render, uint32_t view_index, const struct comp_layer *layers, const uint32_t layer_count, @@ -501,15 +507,15 @@ comp_render_cs_layer(struct render_compute *crc, const struct render_viewport_data *target_view, bool do_timewarp) { - VkSampler clamp_to_edge = crc->r->samplers.clamp_to_edge; - VkSampler clamp_to_border_black = crc->r->samplers.clamp_to_border_black; + VkSampler clamp_to_edge = render->r->samplers.clamp_to_edge; + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; // Not the transform of the views, but the inverse: actual view matrices. struct xrt_matrix_4x4 world_view_mat, eye_view_mat; math_matrix_4x4_view_from_pose(world_pose, &world_view_mat); math_matrix_4x4_view_from_pose(eye_pose, &eye_view_mat); - struct render_buffer *ubo = &crc->r->compute.layer.ubos[view_index]; + struct render_buffer *ubo = &render->r->compute.layer.ubos[view_index]; struct render_compute_layer_ubo_data *ubo_data = ubo->mapped; // Tightly pack layers in data struct. @@ -546,12 +552,12 @@ comp_render_cs_layer(struct render_compute *crc, case XRT_LAYER_PROJECTION_DEPTH: required_image_samplers = 2; break; case XRT_LAYER_QUAD: required_image_samplers = 1; break; default: - VK_ERROR(crc->r->vk, "Skipping layer #%u, unknown type: %u", c_layer_i, data->type); + VK_ERROR(render->r->vk, "Skipping layer #%u, unknown type: %u", c_layer_i, data->type); continue; // Skip this layer if don't know about it. } //! Exit loop if shader cannot receive more image samplers - if (cur_image + required_image_samplers > crc->r->compute.layer.image_array_size) { + if (cur_image + required_image_samplers > render->r->compute.layer.image_array_size) { break; } @@ -620,7 +626,7 @@ comp_render_cs_layer(struct render_compute *crc, default: // Should not get here! assert(false); - VK_ERROR(crc->r->vk, "Should not get here!"); + VK_ERROR(render->r->vk, "Should not get here!"); continue; } @@ -639,16 +645,16 @@ comp_render_cs_layer(struct render_compute *crc, } //! @todo: If Vulkan 1.2, use VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT and skip this - while (cur_image < crc->r->compute.layer.image_array_size) { + while (cur_image < render->r->compute.layer.image_array_size) { src_samplers[cur_image] = clamp_to_edge; - src_image_views[cur_image] = crc->r->mock.color.image_view; + src_image_views[cur_image] = render->r->mock.color.image_view; cur_image++; } - VkDescriptorSet descriptor_set = crc->layer_descriptor_sets[view_index]; + VkDescriptorSet descriptor_set = render->layer_descriptor_sets[view_index]; render_compute_layers( // - crc, // + render, // descriptor_set, // ubo->buffer, // src_samplers, // @@ -660,16 +666,16 @@ comp_render_cs_layer(struct render_compute *crc, } void -comp_render_cs_layers(struct render_compute *crc, +comp_render_cs_layers(struct render_compute *render, const struct comp_layer *layers, const uint32_t layer_count, const struct comp_render_dispatch_data *d, VkImageLayout transition_to) { cmd_barrier_view_images( // - crc->r->vk, // + render->r->vk, // d, // - crc->r->cmd, // cmd + render->r->cmd, // cmd 0, // src_access_mask VK_ACCESS_SHADER_WRITE_BIT, // dst_access_mask VK_IMAGE_LAYOUT_UNDEFINED, // transition_from @@ -681,7 +687,7 @@ comp_render_cs_layers(struct render_compute *crc, const struct comp_render_view_data *view = &d->views[view_index]; comp_render_cs_layer( // - crc, // + render, // view_index, // layers, // layer_count, // @@ -695,9 +701,9 @@ comp_render_cs_layers(struct render_compute *crc, } cmd_barrier_view_images( // - crc->r->vk, // + render->r->vk, // d, // - crc->r->cmd, // cmd + render->r->cmd, // cmd VK_ACCESS_SHADER_WRITE_BIT, // src_access_mask VK_ACCESS_MEMORY_READ_BIT, // dst_access_mask VK_IMAGE_LAYOUT_GENERAL, // transition_from @@ -707,7 +713,7 @@ comp_render_cs_layers(struct render_compute *crc, } void -comp_render_cs_dispatch(struct render_compute *crc, +comp_render_cs_dispatch(struct render_compute *render, const struct comp_layer *layers, const uint32_t layer_count, const struct comp_render_dispatch_data *d) @@ -715,51 +721,69 @@ comp_render_cs_dispatch(struct render_compute *crc, // Convenience. bool fast_path = d->fast_path; - assert(!fast_path || layer_count > 0); + // Only used if fast_path is true. + const struct comp_layer *layer = &layers[0]; + + // Consistency check. + assert(!fast_path || layer_count >= 1); // We want to read from the images afterwards. VkImageLayout transition_to = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - if (fast_path && layers[0].data.type == XRT_LAYER_PROJECTION) { - int i = 0; - const struct comp_layer *layer = &layers[i]; + if (fast_path && layer->data.type == XRT_LAYER_PROJECTION) { + // Fast path. const struct xrt_layer_projection_data *proj = &layer->data.proj; const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; for (uint32_t view = 0; view < d->view_count; ++view) { vds[view] = &proj->v[view]; } do_cs_distortion_for_layer( // - crc, // crc - layer, // layer - vds, // vds - d); // d - } else if (fast_path && layers[0].data.type == XRT_LAYER_PROJECTION_DEPTH) { - int i = 0; - const struct comp_layer *layer = &layers[i]; + render, // + d, // + layer, // + vds); // + + } else if (fast_path && layer->data.type == XRT_LAYER_PROJECTION_DEPTH) { + // Fast path. const struct xrt_layer_projection_depth_data *depth = &layer->data.depth; const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; for (uint32_t view = 0; view < d->view_count; ++view) { vds[view] = &depth->v[view]; } do_cs_distortion_for_layer( // - crc, // crc - layer, // layer - vds, // vds - d); // d + render, // + d, // + layer, // + vds); // + } else if (layer_count > 0) { + // Compute layer squasher + if (fast_path) { + U_LOG_W("Wanted fast path but no projection layer, falling back to layer squasher."); + } + + + /* + * Layer squashing. + */ comp_render_cs_layers( // - crc, // + render, // layers, // layer_count, // d, // transition_to); // + /* + * Distortion. + */ + do_cs_distortion_from_scratch( // - crc, // + render, // d); // } else { + // Just clear the screen do_cs_clear( // - crc, // + render, // d); // } } diff --git a/src/xrt/compositor/util/comp_render_gfx.c b/src/xrt/compositor/util/comp_render_gfx.c index 3f8f95bc8..f942f0195 100644 --- a/src/xrt/compositor/util/comp_render_gfx.c +++ b/src/xrt/compositor/util/comp_render_gfx.c @@ -2,7 +2,7 @@ // SPDX-License-Identifier: BSL-1.0 /*! * @file - * @brief Compositor gfx rendering code. + * @brief Compositor (gfx - graphics shader) rendering code. * @author Jakob Bornecrantz * @author Rylie Pavlik * @ingroup comp_util @@ -235,8 +235,10 @@ add_layer(struct gfx_layer_view_state *state, const struct xrt_layer_data *data, state->premultiplied_alphas[cur_layer] = !is_layer_unpremultiplied(data); } +/// Data setup for a cylinder layer +/// Also allocates and writes a descriptor set! static VkResult -do_cylinder_layer(struct render_gfx *rr, +do_cylinder_layer(struct render_gfx *render, const struct comp_layer *layer, uint32_t view_index, VkSampler clamp_to_edge, @@ -248,7 +250,7 @@ do_cylinder_layer(struct render_gfx *rr, const uint32_t array_index = c->sub.array_index; const struct comp_swapchain_image *image = get_layer_image(layer, 0, c->sub.image_index); - struct vk_bundle *vk = rr->r->vk; + struct vk_bundle *vk = render->r->vk; VkResult ret; // Color @@ -285,10 +287,10 @@ do_cylinder_layer(struct render_gfx *rr, // Can fail if we have too many layers. VkDescriptorSet descriptor_set = VK_NULL_HANDLE; ret = render_gfx_layer_cylinder_alloc_and_write( // - rr, // rr - &data, // data - src_sampler, // src_sampler - src_image_view, // src_image_view + render, // + &data, // + src_sampler, // + src_image_view, // &descriptor_set); // out_descriptor_set VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); @@ -299,8 +301,10 @@ do_cylinder_layer(struct render_gfx *rr, return VK_SUCCESS; } +/// Data setup for an "equirect2" layer +/// Also allocates and writes a descriptor set! static VkResult -do_equirect2_layer(struct render_gfx *rr, +do_equirect2_layer(struct render_gfx *render, const struct comp_layer *layer, uint32_t view_index, VkSampler clamp_to_edge, @@ -312,7 +316,7 @@ do_equirect2_layer(struct render_gfx *rr, const uint32_t array_index = eq2->sub.array_index; const struct comp_swapchain_image *image = get_layer_image(layer, 0, eq2->sub.image_index); - struct vk_bundle *vk = rr->r->vk; + struct vk_bundle *vk = render->r->vk; VkResult ret; // Color @@ -349,10 +353,10 @@ do_equirect2_layer(struct render_gfx *rr, // Can fail if we have too many layers. VkDescriptorSet descriptor_set = VK_NULL_HANDLE; ret = render_gfx_layer_equirect2_alloc_and_write( // - rr, // rr - &data, // data - src_sampler, // src_sampler - src_image_view, // src_image_view + render, // + &data, // + src_sampler, // + src_image_view, // &descriptor_set); // out_descriptor_set VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); @@ -363,8 +367,10 @@ do_equirect2_layer(struct render_gfx *rr, return VK_SUCCESS; } +/// Data setup for a projection layer +/// Also allocates and writes a descriptor set! static VkResult -do_projection_layer(struct render_gfx *rr, +do_projection_layer(struct render_gfx *render, const struct comp_layer *layer, uint32_t view_index, VkSampler clamp_to_edge, @@ -385,7 +391,7 @@ do_projection_layer(struct render_gfx *rr, uint32_t array_index = vd->sub.array_index; const struct comp_swapchain_image *image = get_layer_image(layer, sc_array_index, vd->sub.image_index); - struct vk_bundle *vk = rr->r->vk; + struct vk_bundle *vk = render->r->vk; VkResult ret; // Color VkSampler src_sampler = clamp_to_border_black; @@ -411,10 +417,10 @@ do_projection_layer(struct render_gfx *rr, // Can fail if we have too many layers. VkDescriptorSet descriptor_set = VK_NULL_HANDLE; ret = render_gfx_layer_projection_alloc_and_write( // - rr, // rr - &data, // data - src_sampler, // src_sampler - src_image_view, // src_image_view + render, // + &data, // + src_sampler, // + src_image_view, // &descriptor_set); // out_descriptor_set VK_CHK_AND_RET(ret, "render_gfx_layer_projection_alloc_and_write"); @@ -425,8 +431,10 @@ do_projection_layer(struct render_gfx *rr, return VK_SUCCESS; } +/// Data setup for a quad layer +/// Also allocates and writes a descriptor set! static VkResult -do_quad_layer(struct render_gfx *rr, +do_quad_layer(struct render_gfx *render, const struct comp_layer *layer, uint32_t view_index, VkSampler clamp_to_edge, @@ -438,7 +446,7 @@ do_quad_layer(struct render_gfx *rr, const uint32_t array_index = q->sub.array_index; const struct comp_swapchain_image *image = get_layer_image(layer, 0, q->sub.image_index); - struct vk_bundle *vk = rr->r->vk; + struct vk_bundle *vk = render->r->vk; VkResult ret; // Color @@ -462,10 +470,10 @@ do_quad_layer(struct render_gfx *rr, // Can fail if we have too many layers. VkDescriptorSet descriptor_set = VK_NULL_HANDLE; ret = render_gfx_layer_quad_alloc_and_write( // - rr, // rr - &data, // data - src_sampler, // src_sampler - src_image_view, // src_image_view + render, // + &data, // + src_sampler, // + src_image_view, // &descriptor_set); // out_descriptor_set VK_CHK_AND_RET(ret, "render_gfx_layer_quad_alloc_and_write"); @@ -477,14 +485,14 @@ do_quad_layer(struct render_gfx *rr, } static void -do_layers(struct render_gfx *rr, +do_layers(struct render_gfx *render, const struct comp_layer *layers, uint32_t layer_count, const struct comp_render_dispatch_data *d) { COMP_TRACE_MARKER(); - struct vk_bundle *vk = rr->r->vk; + struct vk_bundle *vk = render->r->vk; VkResult ret; struct gfx_layer_state ls = XRT_STRUCT_INIT; @@ -538,8 +546,8 @@ do_layers(struct render_gfx *rr, assert(layer_count <= RENDER_MAX_LAYERS && "Too many layers"); - VkSampler clamp_to_edge = rr->r->samplers.clamp_to_edge; - VkSampler clamp_to_border_black = rr->r->samplers.clamp_to_border_black; + VkSampler clamp_to_edge = render->r->samplers.clamp_to_edge; + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; for (uint32_t view = 0; view < d->view_count; view++) { @@ -555,43 +563,43 @@ do_layers(struct render_gfx *rr, switch (data->type) { case XRT_LAYER_CYLINDER: ret = do_cylinder_layer( // - rr, // rr - &layers[i], // layer + render, // + &layers[i], // view, // view_index - clamp_to_edge, // clamp_to_edge - clamp_to_border_black, // clamp_to_border_black - state); // state + clamp_to_edge, // + clamp_to_border_black, // + state); // VK_CHK_WITH_GOTO(ret, "do_cylinder_layer", err_layer); break; case XRT_LAYER_EQUIRECT2: ret = do_equirect2_layer( // - rr, // rr - &layers[i], // layer + render, // + &layers[i], // view, // view_index - clamp_to_edge, // clamp_to_edge - clamp_to_border_black, // clamp_to_border_black - state); // state + clamp_to_edge, // + clamp_to_border_black, // + state); // VK_CHK_WITH_GOTO(ret, "do_equirect2_layer", err_layer); break; case XRT_LAYER_PROJECTION: case XRT_LAYER_PROJECTION_DEPTH: ret = do_projection_layer( // - rr, // rr - &layers[i], // layer + render, // + &layers[i], // view, // view_index - clamp_to_edge, // clamp_to_edge - clamp_to_border_black, // clamp_to_border_black - state); // state + clamp_to_edge, // + clamp_to_border_black, // + state); // VK_CHK_WITH_GOTO(ret, "do_projection_layer", err_layer); break; case XRT_LAYER_QUAD: ret = do_quad_layer( // - rr, // rr - &layers[i], // layer + render, // + &layers[i], // view, // view_index - clamp_to_edge, // clamp_to_edge - clamp_to_border_black, // clamp_to_border_black - state); // state + clamp_to_edge, // + clamp_to_border_black, // + state); // VK_CHK_WITH_GOTO(ret, "do_quad_layer", err_layer); break; default: break; @@ -612,12 +620,12 @@ do_layers(struct render_gfx *rr, const struct render_viewport_data *viewport_data = &d->views[view].layer_viewport_data; render_gfx_begin_target( // - rr, // + render, // d->views[view].gfx.rtr, // color); // render_gfx_begin_view( // - rr, // + render, // view, // view_index viewport_data); // viewport_data @@ -628,26 +636,26 @@ do_layers(struct render_gfx *rr, switch (state->types[i]) { case XRT_LAYER_CYLINDER: render_gfx_layer_cylinder( // - rr, // + render, // state->premultiplied_alphas[i], // state->descriptor_sets[i]); // break; case XRT_LAYER_EQUIRECT2: render_gfx_layer_equirect2( // - rr, // + render, // state->premultiplied_alphas[i], // state->descriptor_sets[i]); // break; case XRT_LAYER_PROJECTION: case XRT_LAYER_PROJECTION_DEPTH: render_gfx_layer_projection( // - rr, // + render, // state->premultiplied_alphas[i], // state->descriptor_sets[i]); // break; case XRT_LAYER_QUAD: render_gfx_layer_quad( // - rr, // + render, // state->premultiplied_alphas[i], // state->descriptor_sets[i]); // break; @@ -655,9 +663,9 @@ do_layers(struct render_gfx *rr, } } - render_gfx_end_view(rr); + render_gfx_end_view(render); - render_gfx_end_target(rr); + render_gfx_end_target(render); } @@ -676,12 +684,12 @@ err_layer: */ static void -do_mesh(struct render_gfx *rr, +do_mesh(struct render_gfx *render, bool do_timewarp, const struct gfx_mesh_data *md, const struct comp_render_dispatch_data *d) { - struct vk_bundle *vk = rr->r->vk; + struct vk_bundle *vk = render->r->vk; VkResult ret; /* @@ -711,7 +719,7 @@ do_mesh(struct render_gfx *rr, } ret = render_gfx_mesh_alloc_and_write( // - rr, // + render, // &data, // md->views[i].src_sampler, // md->views[i].src_image_view, // @@ -727,7 +735,7 @@ do_mesh(struct render_gfx *rr, */ render_gfx_begin_target( // - rr, // + render, // d->gfx.rtr, // &background_color_active); // @@ -736,20 +744,20 @@ do_mesh(struct render_gfx *rr, const struct render_viewport_data *viewport_data = &d->views[i].target_viewport_data; render_gfx_begin_view( // - rr, // + render, // i, // view_index - viewport_data); // viewport_data + viewport_data); // render_gfx_mesh_draw( // - rr, // rr + render, // i, // mesh_index - ms.descriptor_sets[i], // descriptor_set - do_timewarp); // do_timewarp + ms.descriptor_sets[i], // + do_timewarp); // - render_gfx_end_view(rr); + render_gfx_end_view(render); } - render_gfx_end_target(rr); + render_gfx_end_target(render); return; @@ -759,14 +767,14 @@ err_no_memory: } static void -do_mesh_from_proj(struct render_gfx *rr, +do_mesh_from_proj(struct render_gfx *render, const struct comp_render_dispatch_data *d, const struct comp_layer *layer, const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]) { const struct xrt_layer_data *data = &layer->data; - const VkSampler clamp_to_border_black = rr->r->samplers.clamp_to_border_black; + const VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; struct gfx_mesh_data md = XRT_STRUCT_INIT; for (uint32_t i = 0; i < d->view_count; i++) { @@ -799,7 +807,7 @@ do_mesh_from_proj(struct render_gfx *rr, } do_mesh( // - rr, // + render, // d->do_timewarp, // &md, // d); // @@ -813,7 +821,7 @@ do_mesh_from_proj(struct render_gfx *rr, */ void -comp_render_gfx_dispatch(struct render_gfx *rr, +comp_render_gfx_dispatch(struct render_gfx *render, const struct comp_layer *layers, const uint32_t layer_count, const struct comp_render_dispatch_data *d) @@ -831,11 +839,11 @@ comp_render_gfx_dispatch(struct render_gfx *rr, // Fast path. const struct xrt_layer_projection_data *proj = &layer->data.proj; const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; - for (uint32_t j = 0; j < d->view_count; ++j) { - vds[j] = &proj->v[j]; + for (uint32_t view = 0; view < d->view_count; ++view) { + vds[view] = &proj->v[view]; } do_mesh_from_proj( // - rr, // + render, // d, // layer, // vds); // @@ -848,20 +856,13 @@ comp_render_gfx_dispatch(struct render_gfx *rr, vds[view] = &depth->v[view]; } do_mesh_from_proj( // - rr, // + render, // d, // layer, // vds); // - } else if (layer_count == 0) { - // Just clear the screen - render_gfx_begin_target( // - rr, // - d->gfx.rtr, // - &background_color_idle); // - - render_gfx_end_target(rr); - } else { + } else if (layer_count > 0) { + // Graphics layer squasher if (fast_path) { U_LOG_W("Wanted fast path but no projection layer, falling back to layer squasher."); } @@ -870,13 +871,11 @@ comp_render_gfx_dispatch(struct render_gfx *rr, /* * Layer squashing. */ - do_layers( // - rr, // rr - layers, // layers - layer_count, // layer_count - d); // d - + render, // + layers, // + layer_count, // + d); // /* * Distortion. @@ -886,18 +885,18 @@ comp_render_gfx_dispatch(struct render_gfx *rr, VkImageLayout transition_to = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; cmd_barrier_view_images( // - rr->r->vk, // + render->r->vk, // d, // - rr->r->cmd, // cmd + render->r->cmd, // cmd VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // src_access_mask VK_ACCESS_SHADER_READ_BIT, // dst_access_mask - transition_from, // transition_from - transition_to, // transition_to + transition_from, // + transition_to, // VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // src_stage_mask VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); // dst_stage_mask // Shared between all views. - VkSampler clamp_to_border_black = rr->r->samplers.clamp_to_border_black; + VkSampler clamp_to_border_black = render->r->samplers.clamp_to_border_black; struct gfx_mesh_data md = XRT_STRUCT_INIT; for (uint32_t i = 0; i < d->view_count; i++) { @@ -907,20 +906,28 @@ comp_render_gfx_dispatch(struct render_gfx *rr, struct xrt_normalized_rect src_norm_rect = d->views[i].layer_norm_rect; gfx_mesh_add_view( // - &md, // md + &md, // i, // view_index - &src_pose, // src_pose - &src_fov, // src_fov - &src_norm_rect, // src_norm_rect + &src_pose, // + &src_fov, // + &src_norm_rect, // clamp_to_border_black, // src_sampler - src_image_view); // src_image_view + src_image_view); // } // We are passing in the same old and new poses. - do_mesh( // - rr, // - false, // do_timewarp - &md, // md - d); // d + do_mesh( // + render, // + false, // do_timewarp + &md, // + d); // + } else { + // Just clear the screen + render_gfx_begin_target( // + render, // + d->gfx.rtr, // + &background_color_idle); // + + render_gfx_end_target(render); } }