+1

src/xrt/compositor/CMakeLists.txt

··· 182 182 main/comp_compositor.c 183 183 main/comp_compositor.h 184 184 main/comp_documentation.h 185 185 + main/comp_main_interface.h 185 186 main/comp_renderer.c 186 187 main/comp_renderer.h 187 188 main/comp_settings.c

+10 -4

src/xrt/compositor/main/comp_renderer.c

··· 582 582 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); // final_layout 583 583 584 584 for (uint32_t i = 0; i < c->nr.view_count; i++) { 585 585 - bret = comp_scratch_single_images_ensure(&r->c->scratch.views[i], &r->c->base.vk, scratch_extent); 585 585 + bret = 586 586 + comp_scratch_single_images_ensure_mutable(&r->c->scratch.views[i], &r->c->base.vk, scratch_extent); 586 587 if (!bret) { 587 588 COMP_ERROR(c, "comp_scratch_single_images_ensure: false"); 588 589 assert(false && "Whelp, can't return an error. But should never really fail."); ··· 937 938 // Scratch image covers the whole image. 938 939 struct xrt_normalized_rect layer_norm_rect = {.x = 0.0f, .y = 0.0f, .w = 1.0f, .h = 1.0f}; 939 940 941 941 + VkImageView sample_view = comp_scratch_single_images_get_sample_view(scratch_view, scratch_index); 942 942 + 940 943 comp_render_gfx_add_view( // 941 944 &data, // 942 945 &world_poses[i], // ··· 946 949 &layer_viewport_data, // 947 950 &layer_norm_rect, // 948 951 rsci->image, // 949 949 - rsci->srgb_view, // 952 952 + sample_view, // 950 953 &vertex_rots[i], // 951 954 &viewport_datas[i]); // target_viewport_data 952 955 ··· 1055 1058 // Scratch image covers the whole image. 1056 1059 struct xrt_normalized_rect layer_norm_rect = {.x = 0.0f, .y = 0.0f, .w = 1.0f, .h = 1.0f}; 1057 1060 1061 1061 + VkImageView sample_view = comp_scratch_single_images_get_sample_view(scratch_view, scratch_index); 1062 1062 + VkImageView storage_view = comp_scratch_single_images_get_storage_view(scratch_view, scratch_index); 1063 1063 + 1058 1064 comp_render_cs_add_view( // 1059 1065 &data, // 1060 1066 &world_poses[i], // ··· 1063 1069 &layer_viewport_data, // 1064 1070 &layer_norm_rect, // 1065 1071 rsci->image, // 1066 1066 - rsci->srgb_view, // 1067 1067 - rsci->unorm_view, // 1072 1072 + sample_view, // 1073 1073 + storage_view, // 1068 1074 &views[i]); // target_viewport_data 1069 1075 1070 1076 if (layer_count == 0) {

+1 -1

src/xrt/compositor/main/comp_window_debug_image.c

··· 136 136 } 137 137 138 138 // Do the allocation. 139 139 - comp_scratch_single_images_ensure(&dit->target, vk, create_info->extent); 139 139 + comp_scratch_single_images_ensure_mutable(&dit->target, vk, create_info->extent); 140 140 141 141 // Share the Vulkan handles of images and image views. 142 142 for (uint32_t i = 0; i < COMP_SCRATCH_NUM_IMAGES; i++) {

+103 -50

src/xrt/compositor/util/comp_scratch.c

··· 1 1 // Copyright 2019-2024, Collabora, Ltd. 2 2 + // Copyright 2024-2025, NVIDIA CORPORATION. 2 3 // SPDX-License-Identifier: BSL-1.0 3 4 /*! 4 5 * @file ··· 25 26 */ 26 27 27 28 static inline void 28 28 - fill_info(VkExtent2D extent, struct xrt_swapchain_create_info *out_info) 29 29 + fill_info(VkExtent2D extent, VkFormat srgb_format, VkFormat unorm_format, struct xrt_swapchain_create_info *out_info) 29 30 { 31 31 + // Must be true. 32 32 + assert(unorm_format != VK_FORMAT_UNDEFINED); 33 33 + 30 34 enum xrt_swapchain_create_flags create = 0; 31 35 32 32 - enum xrt_swapchain_usage_bits bits = // 33 33 - XRT_SWAPCHAIN_USAGE_COLOR | // 34 34 - XRT_SWAPCHAIN_USAGE_SAMPLED | // 35 35 - XRT_SWAPCHAIN_USAGE_TRANSFER_SRC | // 36 36 - XRT_SWAPCHAIN_USAGE_TRANSFER_DST | // 37 37 - XRT_SWAPCHAIN_USAGE_UNORDERED_ACCESS | // 38 38 - XRT_SWAPCHAIN_USAGE_MUTABLE_FORMAT; // 36 36 + enum xrt_swapchain_usage_bits bits = // 37 37 + XRT_SWAPCHAIN_USAGE_COLOR | // 38 38 + XRT_SWAPCHAIN_USAGE_SAMPLED | // 39 39 + XRT_SWAPCHAIN_USAGE_TRANSFER_SRC | // 40 40 + XRT_SWAPCHAIN_USAGE_TRANSFER_DST | // 41 41 + XRT_SWAPCHAIN_USAGE_UNORDERED_ACCESS; // 39 42 40 43 struct xrt_swapchain_create_info info = { 41 44 .create = create, 42 45 .bits = bits, 43 43 - .format = VK_FORMAT_R8G8B8A8_UNORM, 46 46 + .format = unorm_format, 44 47 .sample_count = 1, 45 48 .width = extent.width, 46 49 .height = extent.height, ··· 49 52 .mip_count = 1, 50 53 }; 51 54 52 52 - // Use format list to get good performance everywhere. 53 53 - info.formats[info.format_count++] = VK_FORMAT_R8G8B8A8_UNORM; 54 54 - info.formats[info.format_count++] = VK_FORMAT_R8G8B8A8_SRGB; 55 55 + if (srgb_format != VK_FORMAT_UNDEFINED) { 56 56 + // Use format list to get good performance everywhere. 57 57 + info.bits |= XRT_SWAPCHAIN_USAGE_MUTABLE_FORMAT; 58 58 + info.formats[info.format_count++] = unorm_format; 59 59 + info.formats[info.format_count++] = srgb_format; 60 60 + } else { 61 61 + assert(info.format_count == 0); 62 62 + } 55 63 56 64 *out_info = info; 57 65 } ··· 126 134 //! Handles retrieved. 127 135 xrt_graphics_buffer_handle_t handles[COMP_SCRATCH_NUM_IMAGES]; 128 136 129 129 - //! For automatic conversion to linear. 137 137 + //! For automatic conversion to linear, only populated on mutable. 130 138 VkImageView srgb_views[COMP_SCRATCH_NUM_IMAGES]; 131 139 132 140 //! For storage operations in compute shaders. ··· 134 142 }; 135 143 136 144 static inline bool 137 137 - tmp_init_and_create(struct tmp *t, struct vk_bundle *vk, const struct xrt_swapchain_create_info *info) 145 145 + tmp_init_and_create(struct tmp *t, 146 146 + struct vk_bundle *vk, 147 147 + const struct xrt_swapchain_create_info *info, 148 148 + const VkFormat srgb_format, 149 149 + const VkFormat unorm_format) 138 150 { 139 151 VkResult ret; 140 152 ··· 157 169 */ 158 170 159 171 // Base info. 160 160 - const VkFormat srgb_format = VK_FORMAT_R8G8B8A8_SRGB; 161 161 - const VkFormat unorm_format = VK_FORMAT_R8G8B8A8_UNORM; 162 172 const VkImageViewType view_type = VK_IMAGE_VIEW_TYPE_2D; 163 173 164 174 // Both usages are common. ··· 178 188 for (uint32_t i = 0; i < COMP_SCRATCH_NUM_IMAGES; i++) { 179 189 VkImage image = t->vkic.images[i].handle; 180 190 181 181 - ret = vk_create_view_usage( // 182 182 - vk, // vk_bundle 183 183 - image, // image 184 184 - view_type, // type 185 185 - srgb_format, // format 186 186 - srgb_usage, // image_usage 187 187 - subresource_range, // subresource_range 188 188 - &t->srgb_views[i]); // out_image_view 189 189 - VK_CHK_WITH_GOTO(ret, "vk_create_view_usage(srgb)", err_destroy_views); 191 191 + if (srgb_format != VK_FORMAT_UNDEFINED) { 192 192 + ret = vk_create_view_usage( // 193 193 + vk, // vk_bundle 194 194 + image, // image 195 195 + view_type, // type 196 196 + srgb_format, // format 197 197 + srgb_usage, // image_usage 198 198 + subresource_range, // subresource_range 199 199 + &t->srgb_views[i]); // out_image_view 200 200 + VK_CHK_WITH_GOTO(ret, "vk_create_view_usage(srgb)", err_destroy_views); 190 201 191 191 - VK_NAME_IMAGE_VIEW(vk, t->srgb_views[i], "comp_scratch_image_view(srgb)"); 202 202 + VK_NAME_IMAGE_VIEW(vk, t->srgb_views[i], "comp_scratch_image_view(srgb)"); 203 203 + } 192 204 193 205 ret = vk_create_view_usage( // 194 206 vk, // vk_bundle ··· 255 267 256 268 /* 257 269 * 258 258 - * 'Exported' single functions. 270 270 + * Helper single functions. 259 271 * 260 272 */ 261 273 262 262 - void 263 263 - comp_scratch_single_images_init(struct comp_scratch_single_images *cssi) 264 264 - { 265 265 - // Just to be sure. 266 266 - U_ZERO(cssi); 267 267 - 268 268 - indices_init(&cssi->indices); 269 269 - 270 270 - u_native_images_debug_init(&cssi->unid); 271 271 - 272 272 - // Invalid handle may be different to zero. 273 273 - for (uint32_t i = 0; i < COMP_SCRATCH_NUM_IMAGES; i++) { 274 274 - cssi->native_images[i].handle = XRT_GRAPHICS_BUFFER_HANDLE_INVALID; 275 275 - } 276 276 - } 277 277 - 278 274 bool 279 279 - comp_scratch_single_images_ensure(struct comp_scratch_single_images *cssi, struct vk_bundle *vk, VkExtent2D extent) 275 275 + ensure(struct comp_scratch_single_images *cssi, 276 276 + struct vk_bundle *vk, 277 277 + VkExtent2D extent, 278 278 + const VkFormat srgb_format, 279 279 + const VkFormat unorm_format) 280 280 { 281 281 - if (cssi->info.width == extent.width && cssi->info.height == extent.height) { 281 281 + if (cssi->info.width == extent.width && // 282 282 + cssi->info.height == extent.height && // 283 283 + cssi->info.formats[0] == unorm_format && // 284 284 + cssi->info.formats[1] == srgb_format) { // 282 285 // Our work here is done! 283 286 return true; 284 287 } 285 288 286 289 struct xrt_swapchain_create_info info = XRT_STRUCT_INIT; 287 287 - fill_info(extent, &info); 290 290 + fill_info(extent, srgb_format, unorm_format, &info); 288 291 289 292 struct tmp t; // Is initialized in function. 290 290 - if (!tmp_init_and_create(&t, vk, &info)) { 293 293 + if (!tmp_init_and_create(&t, vk, &info, srgb_format, unorm_format)) { 291 294 VK_ERROR(vk, "Failed to allocate images"); 292 295 return false; 293 296 } ··· 305 308 return true; 306 309 } 307 310 311 311 + 312 312 + /* 313 313 + * 314 314 + * 'Exported' single functions. 315 315 + * 316 316 + */ 317 317 + 318 318 + void 319 319 + comp_scratch_single_images_init(struct comp_scratch_single_images *cssi) 320 320 + { 321 321 + // Just to be sure. 322 322 + U_ZERO(cssi); 323 323 + 324 324 + indices_init(&cssi->indices); 325 325 + 326 326 + u_native_images_debug_init(&cssi->unid); 327 327 + 328 328 + // Invalid handle may be different to zero. 329 329 + for (uint32_t i = 0; i < COMP_SCRATCH_NUM_IMAGES; i++) { 330 330 + cssi->native_images[i].handle = XRT_GRAPHICS_BUFFER_HANDLE_INVALID; 331 331 + } 332 332 + } 333 333 + 334 334 + bool 335 335 + comp_scratch_single_images_ensure(struct comp_scratch_single_images *cssi, 336 336 + struct vk_bundle *vk, 337 337 + VkExtent2D extent, 338 338 + const VkFormat format) 339 339 + { 340 340 + return ensure(cssi, vk, extent, VK_FORMAT_UNDEFINED, format); 341 341 + } 342 342 + 343 343 + /*! 344 344 + * Ensure that the scratch images are allocated and match @p extent size, and @p srgb_format @p unorm_format formats. 345 345 + * 346 346 + * @public @memberof comp_scratch_single_images 347 347 + * 348 348 + * @ingroup comp_util 349 349 + */ 350 350 + bool 351 351 + comp_scratch_single_images_ensure_mutable(struct comp_scratch_single_images *cssi, 352 352 + struct vk_bundle *vk, 353 353 + VkExtent2D extent) 354 354 + { 355 355 + return ensure(cssi, vk, extent, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_R8G8B8A8_UNORM); 356 356 + } 357 357 + 308 358 void 309 359 comp_scratch_single_images_free(struct comp_scratch_single_images *cssi, struct vk_bundle *vk) 310 360 { ··· 402 452 bool 403 453 comp_scratch_stereo_images_ensure(struct comp_scratch_stereo_images *cssi, struct vk_bundle *vk, VkExtent2D extent) 404 454 { 455 455 + const VkFormat srgb_format = VK_FORMAT_R8G8B8A8_SRGB; 456 456 + const VkFormat unorm_format = VK_FORMAT_R8G8B8A8_UNORM; 457 457 + 405 458 if (cssi->info.width == extent.width && cssi->info.height == extent.height) { 406 459 // Our work here is done! 407 460 return true; ··· 409 462 410 463 // Get info we need to share with. 411 464 struct xrt_swapchain_create_info info = XRT_STRUCT_INIT; 412 412 - fill_info(extent, &info); 465 465 + fill_info(extent, srgb_format, unorm_format, &info); 413 466 414 467 struct tmp ts[2]; // Is initialized in function. 415 415 - if (!tmp_init_and_create(&ts[0], vk, &info)) { 468 468 + if (!tmp_init_and_create(&ts[0], vk, &info, srgb_format, unorm_format)) { 416 469 VK_ERROR(vk, "Failed to allocate images for view 0"); 417 470 return false; 418 471 } 419 472 420 420 - if (!tmp_init_and_create(&ts[1], vk, &info)) { 473 473 + if (!tmp_init_and_create(&ts[1], vk, &info, srgb_format, unorm_format)) { 421 474 VK_ERROR(vk, "Failed to allocate images for view 1"); 422 475 goto err_destroy; 423 476 }

+72 -2

src/xrt/compositor/util/comp_scratch.h

··· 1 1 // Copyright 2019-2024, Collabora, Ltd. 2 2 + // Copyright 2024-2025, NVIDIA CORPORATION. 2 3 // SPDX-License-Identifier: BSL-1.0 3 4 /*! 4 5 * @file ··· 99 100 comp_scratch_single_images_init(struct comp_scratch_single_images *cssi); 100 101 101 102 /*! 102 102 - * Ensure that the scratch images are allocated and match @p extent size. 103 103 + * Ensure that the scratch images are allocated and match @p extent size, and 104 104 + * @p format. 105 105 + * 106 106 + * @public @memberof comp_scratch_single_images 107 107 + * 108 108 + * @ingroup comp_util 109 109 + */ 110 110 + bool 111 111 + comp_scratch_single_images_ensure(struct comp_scratch_single_images *cssi, 112 112 + struct vk_bundle *vk, 113 113 + VkExtent2D extent, 114 114 + const VkFormat format); 115 115 + 116 116 + /*! 117 117 + * Ensure that the scratch images are allocated and match @p extent size, 118 118 + * the formats it will get is 8bit SRGB formats. 103 119 * 104 120 * @public @memberof comp_scratch_single_images 105 121 * 106 122 * @ingroup comp_util 107 123 */ 108 124 bool 109 109 - comp_scratch_single_images_ensure(struct comp_scratch_single_images *cssi, struct vk_bundle *vk, VkExtent2D extent); 125 125 + comp_scratch_single_images_ensure_mutable(struct comp_scratch_single_images *cssi, 126 126 + struct vk_bundle *vk, 127 127 + VkExtent2D extent); 110 128 111 129 /*! 112 130 * Free all images allocated, @p init must be called before calling this ··· 129 147 */ 130 148 void 131 149 comp_scratch_single_images_get(struct comp_scratch_single_images *cssi, uint32_t *out_index); 150 150 + 151 151 + /*! 152 152 + * Get the image for the given index. 153 153 + * 154 154 + * @public @memberof comp_scratch_single_images 155 155 + * 156 156 + * @ingroup comp_util 157 157 + */ 158 158 + static inline VkImage 159 159 + comp_scratch_single_images_get_image(struct comp_scratch_single_images *cssi, uint32_t index) 160 160 + { 161 161 + return cssi->images[index].image; 162 162 + } 163 163 + 164 164 + /*! 165 165 + * Get the image view for sampling, it will apply any automatic linearization, 166 166 + * aka sRGB gamma curve correction. 167 167 + * 168 168 + * @public @memberof comp_scratch_single_images 169 169 + * 170 170 + * @ingroup comp_util 171 171 + */ 172 172 + static inline VkImageView 173 173 + comp_scratch_single_images_get_sample_view(struct comp_scratch_single_images *cssi, uint32_t index) 174 174 + { 175 175 + struct render_scratch_color_image *rsci = &cssi->images[index]; 176 176 + 177 177 + VkImageView view = rsci->srgb_view; 178 178 + if (view != VK_NULL_HANDLE) { 179 179 + return view; 180 180 + } 181 181 + 182 182 + // Fallback to unorm view. 183 183 + return rsci->unorm_view; 184 184 + } 185 185 + 186 186 + /*! 187 187 + * Get the image view for storage or direct value, no linearization will be 188 188 + * done. 189 189 + * 190 190 + * @public @memberof comp_scratch_single_images 191 191 + * 192 192 + * @ingroup comp_util 193 193 + */ 194 194 + static inline VkImageView 195 195 + comp_scratch_single_images_get_storage_view(struct comp_scratch_single_images *cssi, uint32_t index) 196 196 + { 197 197 + struct render_scratch_color_image *rsci = &cssi->images[index]; 198 198 + 199 199 + // Always the storage view. 200 200 + return rsci->unorm_view; 201 201 + } 132 202 133 203 /*! 134 204 * After calling @p get and rendering to the image you call this function to