+4 -4

src/xrt/compositor/main/comp_compositor.c

reviewed

··· 407 407 408 408 comp_renderer_destroy(&c->r); 409 409 410 410 - comp_resources_close(&c->nr); 410 410 + render_resources_close(&c->nr); 411 411 412 412 // As long as vk_bundle is valid it's safe to call this function. 413 413 - comp_shaders_close(&c->shaders, vk); 413 413 + render_shaders_close(&c->shaders, vk); 414 414 415 415 // Does NULL checking. 416 416 comp_target_destroy(&c->target); ··· 1086 1086 { 1087 1087 struct vk_bundle *vk = get_vk(c); 1088 1088 1089 1089 - return comp_shaders_load(&c->shaders, vk); 1089 1089 + return render_shaders_load(&c->shaders, vk); 1090 1090 } 1091 1091 1092 1092 static bool 1093 1093 compositor_init_renderer(struct comp_compositor *c) 1094 1094 { 1095 1095 - if (!comp_resources_init(&c->nr, &c->shaders, get_vk(c), c->xdev)) { 1095 1095 + if (!render_resources_init(&c->nr, &c->shaders, get_vk(c), c->xdev)) { 1096 1096 return false; 1097 1097 } 1098 1098

+2 -2

src/xrt/compositor/main/comp_compositor.h

reviewed

··· 91 91 struct comp_settings settings; 92 92 93 93 //! Vulkan shaders that the compositor uses. 94 94 - struct comp_shaders shaders; 94 94 + struct render_shaders shaders; 95 95 96 96 //! Timestamp of last-rendered (immersive) frame. 97 97 int64_t last_frame_time_ns; ··· 129 129 bool atw_off; 130 130 } debug; 131 131 132 132 - struct comp_resources nr; 132 132 + struct render_resources nr; 133 133 }; 134 134 135 135

+6 -3

src/xrt/compositor/main/comp_layer_renderer.c

reviewed

··· 468 468 } 469 469 470 470 static bool 471 471 - _init( 472 472 - struct comp_layer_renderer *self, struct comp_shaders *s, struct vk_bundle *vk, VkExtent2D extent, VkFormat format) 471 471 + _init(struct comp_layer_renderer *self, 472 472 + struct render_shaders *s, 473 473 + struct vk_bundle *vk, 474 474 + VkExtent2D extent, 475 475 + VkFormat format) 473 476 { 474 477 self->vk = vk; 475 478 ··· 532 535 } 533 536 534 537 struct comp_layer_renderer * 535 535 - comp_layer_renderer_create(struct vk_bundle *vk, struct comp_shaders *s, VkExtent2D extent, VkFormat format) 538 538 + comp_layer_renderer_create(struct vk_bundle *vk, struct render_shaders *s, VkExtent2D extent, VkFormat format) 536 539 { 537 540 struct comp_layer_renderer *r = U_TYPED_CALLOC(struct comp_layer_renderer); 538 541 _init(r, s, vk, extent, format);

+1 -1

src/xrt/compositor/main/comp_layer_renderer.h

reviewed

··· 68 68 * @public @memberof comp_layer_renderer 69 69 */ 70 70 struct comp_layer_renderer * 71 71 - comp_layer_renderer_create(struct vk_bundle *vk, struct comp_shaders *s, VkExtent2D extent, VkFormat format); 71 71 + comp_layer_renderer_create(struct vk_bundle *vk, struct render_shaders *s, VkExtent2D extent, VkFormat format); 72 72 73 73 /*! 74 74 * Destroy the layer renderer and set the pointer to NULL.

+84 -84

src/xrt/compositor/main/comp_renderer.c

reviewed

··· 106 106 * comp_target images. Each target resources holds all of the resources 107 107 * needed to render to that target and its views. 108 108 */ 109 109 - struct comp_rendering_target_resources *rtr_array; 109 109 + struct render_gfx_target_resources *rtr_array; 110 110 111 111 /*! 112 112 * Array of fences equal in size to the number of comp_target images. ··· 168 168 169 169 static void 170 170 calc_viewport_data(struct comp_renderer *r, 171 171 - struct comp_viewport_data *out_l_viewport_data, 172 172 - struct comp_viewport_data *out_r_viewport_data) 171 171 + struct render_viewport_data *out_l_viewport_data, 172 172 + struct render_viewport_data *out_r_viewport_data) 173 173 { 174 174 struct comp_compositor *c = r->c; 175 175 ··· 189 189 struct xrt_view *l_v = &r->c->xdev->hmd->views[0]; 190 190 struct xrt_view *r_v = &r->c->xdev->hmd->views[1]; 191 191 192 192 - struct comp_viewport_data l_viewport_data; 193 193 - struct comp_viewport_data r_viewport_data; 192 192 + struct render_viewport_data l_viewport_data; 193 193 + struct render_viewport_data r_viewport_data; 194 194 195 195 if (pre_rotate) { 196 196 - l_viewport_data = (struct comp_viewport_data){ 196 196 + l_viewport_data = (struct render_viewport_data){ 197 197 .x = (uint32_t)(l_v->viewport.y_pixels * scale_x), 198 198 .y = (uint32_t)(l_v->viewport.x_pixels * scale_y), 199 199 .w = (uint32_t)(l_v->viewport.h_pixels * scale_x), 200 200 .h = (uint32_t)(l_v->viewport.w_pixels * scale_y), 201 201 }; 202 202 - r_viewport_data = (struct comp_viewport_data){ 202 202 + r_viewport_data = (struct render_viewport_data){ 203 203 .x = (uint32_t)(r_v->viewport.y_pixels * scale_x), 204 204 .y = (uint32_t)(r_v->viewport.x_pixels * scale_y), 205 205 .w = (uint32_t)(r_v->viewport.h_pixels * scale_x), 206 206 .h = (uint32_t)(r_v->viewport.w_pixels * scale_y), 207 207 }; 208 208 } else { 209 209 - l_viewport_data = (struct comp_viewport_data){ 209 209 + l_viewport_data = (struct render_viewport_data){ 210 210 .x = (uint32_t)(l_v->viewport.x_pixels * scale_x), 211 211 .y = (uint32_t)(l_v->viewport.y_pixels * scale_y), 212 212 .w = (uint32_t)(l_v->viewport.w_pixels * scale_x), 213 213 .h = (uint32_t)(l_v->viewport.h_pixels * scale_y), 214 214 }; 215 215 - r_viewport_data = (struct comp_viewport_data){ 215 215 + r_viewport_data = (struct render_viewport_data){ 216 216 .x = (uint32_t)(r_v->viewport.x_pixels * scale_x), 217 217 .y = (uint32_t)(r_v->viewport.y_pixels * scale_y), 218 218 .w = (uint32_t)(r_v->viewport.w_pixels * scale_x), ··· 227 227 //! @pre comp_target_has_images(r->c->target) 228 228 static void 229 229 renderer_build_rendering_target_resources(struct comp_renderer *r, 230 230 - struct comp_rendering_target_resources *rtr, 230 230 + struct render_gfx_target_resources *rtr, 231 231 uint32_t index) 232 232 { 233 233 COMP_TRACE_MARKER(); 234 234 235 235 struct comp_compositor *c = r->c; 236 236 237 237 - struct comp_target_data data; 237 237 + struct render_gfx_target_data data; 238 238 data.format = r->c->target->format; 239 239 data.is_external = true; 240 240 data.width = r->c->target->width; 241 241 data.height = r->c->target->height; 242 242 243 243 - comp_rendering_target_resources_init(rtr, &c->nr, r->c->target->images[index].view, &data); 243 243 + render_gfx_target_resources_init(rtr, &c->nr, r->c->target->images[index].view, &data); 244 244 } 245 245 246 246 //! @pre comp_target_has_images(r->c->target) 247 247 static void 248 248 renderer_build_rendering(struct comp_renderer *r, 249 249 - struct comp_rendering *rr, 250 250 - struct comp_rendering_target_resources *rtr, 249 249 + struct render_gfx *rr, 250 250 + struct render_gfx_target_resources *rtr, 251 251 VkSampler src_samplers[2], 252 252 VkImageView src_image_views[2], 253 253 struct xrt_normalized_rect src_norm_rects[2]) ··· 268 268 pre_rotate = true; 269 269 } 270 270 271 271 - struct comp_viewport_data l_viewport_data; 272 272 - struct comp_viewport_data r_viewport_data; 271 271 + struct render_viewport_data l_viewport_data; 272 272 + struct render_viewport_data r_viewport_data; 273 273 274 274 calc_viewport_data(r, &l_viewport_data, &r_viewport_data); 275 275 ··· 281 281 * Init 282 282 */ 283 283 284 284 - comp_rendering_init(rr, &c->nr); 284 284 + render_gfx_init(rr, &c->nr); 285 285 286 286 287 287 /* 288 288 * Update 289 289 */ 290 290 291 291 - struct comp_mesh_ubo_data distortion_data[2] = { 291 291 + struct render_gfx_mesh_ubo_data distortion_data[2] = { 292 292 { 293 293 .vertex_rot = l_v->rot, 294 294 .post_transform = src_norm_rects[0], ··· 316 316 &distortion_data[1].vertex_rot); // 317 317 } 318 318 319 319 - comp_draw_update_distortion(rr, // 320 320 - 0, // view_index 321 321 - src_samplers[0], // 322 322 - src_image_views[0], // 323 323 - &distortion_data[0]); // 319 319 + render_gfx_update_distortion(rr, // 320 320 + 0, // view_index 321 321 + src_samplers[0], // 322 322 + src_image_views[0], // 323 323 + &distortion_data[0]); // 324 324 325 325 - comp_draw_update_distortion(rr, // 326 326 - 1, // view_index 327 327 - src_samplers[1], // 328 328 - src_image_views[1], // 329 329 - &distortion_data[1]); // 325 325 + render_gfx_update_distortion(rr, // 326 326 + 1, // view_index 327 327 + src_samplers[1], // 328 328 + src_image_views[1], // 329 329 + &distortion_data[1]); // 330 330 331 331 332 332 /* 333 333 * Target 334 334 */ 335 335 336 336 - comp_draw_begin_target( // 337 337 - rr, // 338 338 - rtr); // 336 336 + render_gfx_begin_target( // 337 337 + rr, // 338 338 + rtr); // 339 339 340 340 341 341 /* 342 342 * Viewport one 343 343 */ 344 344 345 345 - comp_draw_begin_view(rr, // 346 346 - 0, // view_index 347 347 - &l_viewport_data); // viewport_data 345 345 + render_gfx_begin_view(rr, // 346 346 + 0, // view_index 347 347 + &l_viewport_data); // viewport_data 348 348 349 349 - comp_draw_distortion(rr); 349 349 + render_gfx_distortion(rr); 350 350 351 351 - comp_draw_end_view(rr); 351 351 + render_gfx_end_view(rr); 352 352 353 353 354 354 /* 355 355 * Viewport two 356 356 */ 357 357 358 358 - comp_draw_begin_view(rr, // 359 359 - 1, // view_index 360 360 - &r_viewport_data); // viewport_data 358 358 + render_gfx_begin_view(rr, // 359 359 + 1, // view_index 360 360 + &r_viewport_data); // viewport_data 361 361 362 362 - comp_draw_distortion(rr); 362 362 + render_gfx_distortion(rr); 363 363 364 364 - comp_draw_end_view(rr); 364 364 + render_gfx_end_view(rr); 365 365 366 366 367 367 /* 368 368 * End 369 369 */ 370 370 371 371 - comp_draw_end_target(rr); 371 371 + render_gfx_end_target(rr); 372 372 373 373 // Make the command buffer usable. 374 374 - comp_rendering_finalize(rr); 374 374 + render_gfx_finalize(rr); 375 375 } 376 376 377 377 /*! ··· 393 393 394 394 bool use_compute = r->settings->use_compute; 395 395 if (!use_compute) { 396 396 - r->rtr_array = U_TYPED_ARRAY_CALLOC(struct comp_rendering_target_resources, r->buffer_count); 396 396 + r->rtr_array = U_TYPED_ARRAY_CALLOC(struct render_gfx_target_resources, r->buffer_count); 397 397 398 398 for (uint32_t i = 0; i < r->buffer_count; ++i) { 399 399 renderer_build_rendering_target_resources(r, &r->rtr_array[i], i); ··· 426 426 // Renderings 427 427 if (r->buffer_count > 0 && r->rtr_array != NULL) { 428 428 for (uint32_t i = 0; i < r->buffer_count; i++) { 429 429 - comp_rendering_target_resources_close(&r->rtr_array[i]); 429 429 + render_gfx_target_resources_close(&r->rtr_array[i]); 430 430 } 431 431 432 432 free(r->rtr_array); ··· 801 801 802 802 static void 803 803 do_gfx_mesh_and_proj(struct comp_renderer *r, 804 804 - struct comp_rendering *rr, 805 805 - struct comp_rendering_target_resources *rts, 804 804 + struct render_gfx *rr, 805 805 + struct render_gfx_target_resources *rts, 806 806 const struct comp_layer *layer, 807 807 const struct xrt_layer_projection_view_data *lvd, 808 808 const struct xrt_layer_projection_view_data *rvd) ··· 835 835 } 836 836 837 837 static void 838 838 - dispatch_graphics(struct comp_renderer *r, struct comp_rendering *rr) 838 838 + dispatch_graphics(struct comp_renderer *r, struct render_gfx *rr) 839 839 { 840 840 COMP_TRACE_MARKER(); 841 841 842 842 struct comp_compositor *c = r->c; 843 843 struct comp_target *ct = c->target; 844 844 845 845 - struct comp_rendering_target_resources *rtr = &r->rtr_array[r->acquired_buffer]; 845 845 + struct render_gfx_target_resources *rtr = &r->rtr_array[r->acquired_buffer]; 846 846 bool one_projection_layer_fast_path = c->base.slot.one_projection_layer_fast_path; 847 847 848 848 // No fast path, standard layer renderer path. ··· 968 968 969 969 static void 970 970 do_projection_layers(struct comp_renderer *r, 971 971 - struct comp_rendering_compute *crc, 971 971 + struct render_compute *crc, 972 972 const struct comp_layer *layer, 973 973 const struct xrt_layer_projection_view_data *lvd, 974 974 const struct xrt_layer_projection_view_data *rvd) ··· 979 979 const struct comp_swapchain_image *left = &layer->sc_array[0]->images[lvd->sub.image_index]; 980 980 const struct comp_swapchain_image *right = &layer->sc_array[1]->images[rvd->sub.image_index]; 981 981 982 982 - struct comp_viewport_data views[2]; 982 982 + struct render_viewport_data views[2]; 983 983 calc_viewport_data(r, &views[0], &views[1]); 984 984 985 985 VkImage target_image = r->c->target->images[r->acquired_buffer].handle; ··· 1017 1017 }; 1018 1018 1019 1019 if (r->c->debug.atw_off) { 1020 1020 - comp_rendering_compute_projection( // 1021 1021 - crc, // 1022 1022 - src_samplers, // 1023 1023 - src_image_views, // 1024 1024 - src_norm_rects, // 1025 1025 - target_image, // 1026 1026 - target_image_view, // 1027 1027 - views); // 1020 1020 + render_compute_projection( // 1021 1021 + crc, // 1022 1022 + src_samplers, // 1023 1023 + src_image_views, // 1024 1024 + src_norm_rects, // 1025 1025 + target_image, // 1026 1026 + target_image_view, // 1027 1027 + views); // 1028 1028 } else { 1029 1029 - comp_rendering_compute_projection_timewarp( // 1030 1030 - crc, // 1031 1031 - src_samplers, // 1032 1032 - src_image_views, // 1033 1033 - src_norm_rects, // 1034 1034 - src_poses, // 1035 1035 - src_fovs, // 1036 1036 - new_view_poses, // 1037 1037 - target_image, // 1038 1038 - target_image_view, // 1039 1039 - views); // 1029 1029 + render_compute_projection_timewarp( // 1030 1030 + crc, // 1031 1031 + src_samplers, // 1032 1032 + src_image_views, // 1033 1033 + src_norm_rects, // 1034 1034 + src_poses, // 1035 1035 + src_fovs, // 1036 1036 + new_view_poses, // 1037 1037 + target_image, // 1038 1038 + target_image_view, // 1039 1039 + views); // 1040 1040 } 1041 1041 } 1042 1042 1043 1043 static void 1044 1044 - dispatch_compute(struct comp_renderer *r, struct comp_rendering_compute *crc) 1044 1044 + dispatch_compute(struct comp_renderer *r, struct render_compute *crc) 1045 1045 { 1046 1046 COMP_TRACE_MARKER(); 1047 1047 1048 1048 struct comp_compositor *c = r->c; 1049 1049 struct comp_target *ct = c->target; 1050 1050 1051 1051 - comp_rendering_compute_init(crc, &c->nr); 1052 1052 - comp_rendering_compute_begin(crc); 1051 1051 + render_compute_init(crc, &c->nr); 1052 1052 + render_compute_begin(crc); 1053 1053 1054 1054 - struct comp_viewport_data views[2]; 1054 1054 + struct render_viewport_data views[2]; 1055 1055 calc_viewport_data(r, &views[0], &views[1]); 1056 1056 1057 1057 VkImage target_image = r->c->target->images[r->acquired_buffer].handle; ··· 1075 1075 1076 1076 do_projection_layers(r, crc, layer, lvd, rvd); 1077 1077 } else { 1078 1078 - comp_rendering_compute_clear( // 1079 1079 - crc, // 1080 1080 - target_image, // 1081 1081 - target_image_view, // 1082 1082 - views); // 1078 1078 + render_compute_clear( // 1079 1079 + crc, // 1080 1080 + target_image, // 1081 1081 + target_image_view, // 1082 1082 + views); // 1083 1083 } 1084 1084 1085 1085 - comp_rendering_compute_end(crc); 1085 1085 + render_compute_end(crc); 1086 1086 1087 1087 comp_target_mark_submit(ct, c->frame.rendering.id, os_monotonic_get_ns()); 1088 1088 ··· 1475 1475 comp_target_update_timings(ct); 1476 1476 1477 1477 bool use_compute = r->settings->use_compute; 1478 1478 - struct comp_rendering rr = {0}; 1479 1479 - struct comp_rendering_compute crc = {0}; 1478 1478 + struct render_gfx rr = {0}; 1479 1479 + struct render_compute crc = {0}; 1480 1480 if (use_compute) { 1481 1481 dispatch_compute(r, &crc); 1482 1482 } else { ··· 1507 1507 1508 1508 1509 1509 if (use_compute) { 1510 1510 - comp_rendering_compute_close(&crc); 1510 1510 + render_compute_close(&crc); 1511 1511 } else { 1512 1512 - comp_rendering_close(&rr); 1512 1512 + render_gfx_close(&rr); 1513 1513 } 1514 1514 1515 1515 /*

+18 -18

src/xrt/compositor/render/comp_buffer.c

reviewed

··· 121 121 */ 122 122 123 123 VkResult 124 124 - comp_buffer_init(struct vk_bundle *vk, 125 125 - struct comp_buffer *buffer, 126 126 - VkBufferUsageFlags usage_flags, 127 127 - VkMemoryPropertyFlags memory_property_flags, 128 128 - VkDeviceSize size) 124 124 + render_buffer_init(struct vk_bundle *vk, 125 125 + struct render_buffer *buffer, 126 126 + VkBufferUsageFlags usage_flags, 127 127 + VkMemoryPropertyFlags memory_property_flags, 128 128 + VkDeviceSize size) 129 129 { 130 130 VkResult ret; 131 131 ··· 146 146 } 147 147 148 148 VkResult 149 149 - comp_buffer_init_exportable(struct vk_bundle *vk, 150 150 - struct comp_buffer *buffer, 151 151 - VkBufferUsageFlags usage_flags, 152 152 - VkMemoryPropertyFlags memory_property_flags, 153 153 - VkDeviceSize size) 149 149 + render_buffer_init_exportable(struct vk_bundle *vk, 150 150 + struct render_buffer *buffer, 151 151 + VkBufferUsageFlags usage_flags, 152 152 + VkMemoryPropertyFlags memory_property_flags, 153 153 + VkDeviceSize size) 154 154 { 155 155 VkResult ret; 156 156 ··· 199 199 } 200 200 201 201 void 202 202 - comp_buffer_close(struct vk_bundle *vk, struct comp_buffer *buffer) 202 202 + render_buffer_close(struct vk_bundle *vk, struct render_buffer *buffer) 203 203 { 204 204 if (buffer->buffer != VK_NULL_HANDLE) { 205 205 vk->vkDestroyBuffer(vk->device, buffer->buffer, NULL); ··· 212 212 } 213 213 214 214 VkResult 215 215 - comp_buffer_map(struct vk_bundle *vk, struct comp_buffer *buffer) 215 215 + render_buffer_map(struct vk_bundle *vk, struct render_buffer *buffer) 216 216 { 217 217 return vk->vkMapMemory(vk->device, // 218 218 buffer->memory, // memory ··· 223 223 } 224 224 225 225 void 226 226 - comp_buffer_unmap(struct vk_bundle *vk, struct comp_buffer *buffer) 226 226 + render_buffer_unmap(struct vk_bundle *vk, struct render_buffer *buffer) 227 227 { 228 228 if (buffer->mapped != NULL) { 229 229 vk->vkUnmapMemory(vk->device, buffer->memory); ··· 232 232 } 233 233 234 234 VkResult 235 235 - comp_buffer_map_and_write(struct vk_bundle *vk, struct comp_buffer *buffer, void *data, VkDeviceSize size) 235 235 + render_buffer_map_and_write(struct vk_bundle *vk, struct render_buffer *buffer, void *data, VkDeviceSize size) 236 236 { 237 237 VkResult ret; 238 238 ··· 242 242 } 243 243 244 244 if (buffer->mapped == NULL) { 245 245 - ret = comp_buffer_map(vk, buffer); 245 245 + ret = render_buffer_map(vk, buffer); 246 246 if (ret != VK_SUCCESS) { 247 247 return ret; 248 248 } ··· 254 254 } 255 255 256 256 VkResult 257 257 - comp_buffer_write(struct vk_bundle *vk, struct comp_buffer *buffer, void *data, VkDeviceSize size) 257 257 + render_buffer_write(struct vk_bundle *vk, struct render_buffer *buffer, void *data, VkDeviceSize size) 258 258 { 259 259 if (size > buffer->allocation_size) { 260 260 VK_ERROR(vk, "Trying to write more the buffer size!"); ··· 263 263 264 264 bool mapped = buffer->mapped != NULL; 265 265 if (!mapped) { 266 266 - VkResult ret = comp_buffer_map(vk, buffer); 266 266 + VkResult ret = render_buffer_map(vk, buffer); 267 267 if (ret != VK_SUCCESS) { 268 268 return ret; 269 269 } ··· 273 273 274 274 // Only unmap if we did the mapping. 275 275 if (!mapped) { 276 276 - comp_buffer_unmap(vk, buffer); 276 276 + render_buffer_unmap(vk, buffer); 277 277 } 278 278 279 279 return VK_SUCCESS;

+47 -44

src/xrt/compositor/render/comp_compute.c

reviewed

··· 49 49 */ 50 50 51 51 /*! 52 52 - * Get the @ref vk_bundle from @ref comp_rendering_compute. 52 52 + * Get the @ref vk_bundle from @ref render_compute. 53 53 */ 54 54 static inline struct vk_bundle * 55 55 - vk_from_crc(struct comp_rendering_compute *crc) 55 55 + vk_from_crc(struct render_compute *crc) 56 56 { 57 57 return crc->r->vk; 58 58 } ··· 61 61 * For dispatching compute to the view, calculate the number of groups. 62 62 */ 63 63 static void 64 64 - calc_dispatch_dims(const struct comp_viewport_data views[2], uint32_t *out_w, uint32_t *out_h) 64 64 + calc_dispatch_dims(const struct render_viewport_data views[2], uint32_t *out_w, uint32_t *out_h) 65 65 { 66 66 #define IMAX(a, b) ((a) > (b) ? (a) : (b)) 67 67 uint32_t w = IMAX(views[0].w, views[1].w); ··· 255 255 */ 256 256 257 257 bool 258 258 - comp_rendering_compute_init(struct comp_rendering_compute *crc, struct comp_resources *r) 258 258 + render_compute_init(struct render_compute *crc, struct render_resources *r) 259 259 { 260 260 assert(crc->r == NULL); 261 261 ··· 274 274 } 275 275 276 276 bool 277 277 - comp_rendering_compute_begin(struct comp_rendering_compute *crc) 277 277 + render_compute_begin(struct render_compute *crc) 278 278 { 279 279 struct vk_bundle *vk = vk_from_crc(crc); 280 280 ··· 284 284 } 285 285 286 286 bool 287 287 - comp_rendering_compute_end(struct comp_rendering_compute *crc) 287 287 + render_compute_end(struct render_compute *crc) 288 288 { 289 289 struct vk_bundle *vk = vk_from_crc(crc); 290 290 ··· 294 294 } 295 295 296 296 void 297 297 - comp_rendering_compute_close(struct comp_rendering_compute *crc) 297 297 + render_compute_close(struct render_compute *crc) 298 298 { 299 299 assert(crc->r != NULL); 300 300 ··· 311 311 } 312 312 313 313 void 314 314 - comp_rendering_compute_projection_timewarp(struct comp_rendering_compute *crc, 315 315 - VkSampler src_samplers[2], 316 316 - VkImageView src_image_views[2], 317 317 - const struct xrt_normalized_rect src_norm_rects[2], 318 318 - const struct xrt_pose src_poses[2], 319 319 - const struct xrt_fov src_fovs[2], 320 320 - const struct xrt_pose new_poses[2], 321 321 - VkImage target_image, 322 322 - VkImageView target_image_view, 323 323 - const struct comp_viewport_data views[2]) 314 314 + render_compute_projection_timewarp(struct render_compute *crc, 315 315 + VkSampler src_samplers[2], 316 316 + VkImageView src_image_views[2], 317 317 + const struct xrt_normalized_rect src_norm_rects[2], 318 318 + const struct xrt_pose src_poses[2], 319 319 + const struct xrt_fov src_fovs[2], 320 320 + const struct xrt_pose new_poses[2], 321 321 + VkImage target_image, 322 322 + VkImageView target_image_view, 323 323 + const struct render_viewport_data views[2]) 324 324 { 325 325 assert(crc->r != NULL); 326 326 327 327 struct vk_bundle *vk = vk_from_crc(crc); 328 328 - struct comp_resources *r = crc->r; 328 328 + struct render_resources *r = crc->r; 329 329 330 330 331 331 /* ··· 333 333 */ 334 334 335 335 struct xrt_matrix_4x4 time_warp_matrix[2]; 336 336 - comp_calc_time_warp_matrix( // 337 337 - &src_poses[0], // 338 338 - &src_fovs[0], // 339 339 - &new_poses[0], // 340 340 - &time_warp_matrix[0]); // 341 341 - comp_calc_time_warp_matrix( // 342 342 - &src_poses[1], // 343 343 - &src_fovs[1], // 344 344 - &new_poses[1], // 345 345 - &time_warp_matrix[1]); // 336 336 + render_calc_time_warp_matrix( // 337 337 + &src_poses[0], // 338 338 + &src_fovs[0], // 339 339 + &new_poses[0], // 340 340 + &time_warp_matrix[0]); // 341 341 + render_calc_time_warp_matrix( // 342 342 + &src_poses[1], // 343 343 + &src_fovs[1], // 344 344 + &new_poses[1], // 345 345 + &time_warp_matrix[1]); // 346 346 347 347 - struct comp_ubo_compute_data *data = (struct comp_ubo_compute_data *)r->compute.ubo.mapped; 347 347 + struct render_compute_distortion_ubo_data *data = 348 348 + (struct render_compute_distortion_ubo_data *)r->compute.ubo.mapped; 348 349 data->views[0] = views[0]; 349 350 data->views[1] = views[1]; 350 351 data->pre_transforms[0] = r->distortion.uv_to_tanangle[0]; ··· 449 450 } 450 451 451 452 void 452 452 - comp_rendering_compute_projection(struct comp_rendering_compute *crc, 453 453 - VkSampler src_samplers[2], 454 454 - VkImageView src_image_views[2], 455 455 - const struct xrt_normalized_rect src_norm_rects[2], 456 456 - VkImage target_image, 457 457 - VkImageView target_image_view, 458 458 - const struct comp_viewport_data views[2]) 453 453 + render_compute_projection(struct render_compute *crc, 454 454 + VkSampler src_samplers[2], 455 455 + VkImageView src_image_views[2], 456 456 + const struct xrt_normalized_rect src_norm_rects[2], 457 457 + VkImage target_image, 458 458 + VkImageView target_image_view, 459 459 + const struct render_viewport_data views[2]) 459 460 { 460 461 assert(crc->r != NULL); 461 462 462 463 struct vk_bundle *vk = vk_from_crc(crc); 463 463 - struct comp_resources *r = crc->r; 464 464 + struct render_resources *r = crc->r; 464 465 465 466 466 467 /* 467 468 * UBO 468 469 */ 469 470 470 470 - struct comp_ubo_compute_data *data = (struct comp_ubo_compute_data *)r->compute.ubo.mapped; 471 471 + struct render_compute_distortion_ubo_data *data = 472 472 + (struct render_compute_distortion_ubo_data *)r->compute.ubo.mapped; 471 473 data->views[0] = views[0]; 472 474 data->views[1] = views[1]; 473 475 data->post_transforms[0] = src_norm_rects[0]; ··· 568 570 } 569 571 570 572 void 571 571 - comp_rendering_compute_clear(struct comp_rendering_compute *crc, // 572 572 - VkImage target_image, // 573 573 - VkImageView target_image_view, // 574 574 - const struct comp_viewport_data views[2]) // 573 573 + render_compute_clear(struct render_compute *crc, // 574 574 + VkImage target_image, // 575 575 + VkImageView target_image_view, // 576 576 + const struct render_viewport_data views[2]) // 575 577 { 576 578 assert(crc->r != NULL); 577 579 578 580 struct vk_bundle *vk = vk_from_crc(crc); 579 579 - struct comp_resources *r = crc->r; 581 581 + struct render_resources *r = crc->r; 580 582 581 583 582 584 /* ··· 589 591 math_matrix_4x4_identity(&transforms[i]); 590 592 } 591 593 592 592 - struct comp_ubo_compute_data *data = (struct comp_ubo_compute_data *)r->compute.ubo.mapped; 594 594 + struct render_compute_distortion_ubo_data *data = 595 595 + (struct render_compute_distortion_ubo_data *)r->compute.ubo.mapped; 593 596 data->views[0] = views[0]; 594 597 data->views[1] = views[1]; 595 598

+120 -111

src/xrt/compositor/render/comp_render.h

reviewed

··· 57 57 * in [-1, 1] space that needs a perspective divide. 58 58 */ 59 59 void 60 60 - comp_calc_time_warp_matrix(const struct xrt_pose *src_pose, 61 61 - const struct xrt_fov *src_fov, 62 62 - const struct xrt_pose *new_pose, 63 63 - struct xrt_matrix_4x4 *matrix); 60 60 + render_calc_time_warp_matrix(const struct xrt_pose *src_pose, 61 61 + const struct xrt_fov *src_fov, 62 62 + const struct xrt_pose *new_pose, 63 63 + struct xrt_matrix_4x4 *matrix); 64 64 65 65 66 66 /* ··· 72 72 /*! 73 73 * Holds all shaders. 74 74 */ 75 75 - struct comp_shaders 75 75 + struct render_shaders 76 76 { 77 77 VkShaderModule clear_comp; 78 78 VkShaderModule distortion_comp; ··· 95 95 * Loads all of the shaders that the compositor uses. 96 96 */ 97 97 bool 98 98 - comp_shaders_load(struct comp_shaders *s, struct vk_bundle *vk); 98 98 + render_shaders_load(struct render_shaders *s, struct vk_bundle *vk); 99 99 100 100 /*! 101 101 * Unload and cleanup shaders. 102 102 */ 103 103 void 104 104 - comp_shaders_close(struct comp_shaders *s, struct vk_bundle *vk); 104 104 + render_shaders_close(struct render_shaders *s, struct vk_bundle *vk); 105 105 106 106 107 107 /* ··· 113 113 /*! 114 114 * Helper struct holding a buffer and its memory. 115 115 */ 116 116 - struct comp_buffer 116 116 + struct render_buffer 117 117 { 118 118 //! Backing memory. 119 119 VkDeviceMemory memory; ··· 137 137 * Initialize a buffer. 138 138 */ 139 139 VkResult 140 140 - comp_buffer_init(struct vk_bundle *vk, 141 141 - struct comp_buffer *buffer, 142 142 - VkBufferUsageFlags usage_flags, 143 143 - VkMemoryPropertyFlags memory_property_flags, 144 144 - VkDeviceSize size); 140 140 + render_buffer_init(struct vk_bundle *vk, 141 141 + struct render_buffer *buffer, 142 142 + VkBufferUsageFlags usage_flags, 143 143 + VkMemoryPropertyFlags memory_property_flags, 144 144 + VkDeviceSize size); 145 145 146 146 /*! 147 147 * Initialize a buffer, making it exportable. 148 148 */ 149 149 VkResult 150 150 - comp_buffer_init_exportable(struct vk_bundle *vk, 151 151 - struct comp_buffer *buffer, 152 152 - VkBufferUsageFlags usage_flags, 153 153 - VkMemoryPropertyFlags memory_property_flags, 154 154 - VkDeviceSize size); 150 150 + render_buffer_init_exportable(struct vk_bundle *vk, 151 151 + struct render_buffer *buffer, 152 152 + VkBufferUsageFlags usage_flags, 153 153 + VkMemoryPropertyFlags memory_property_flags, 154 154 + VkDeviceSize size); 155 155 156 156 /*! 157 157 * Frees all resources that this buffer has, but does not free the buffer itself. 158 158 */ 159 159 void 160 160 - comp_buffer_close(struct vk_bundle *vk, struct comp_buffer *buffer); 160 160 + render_buffer_close(struct vk_bundle *vk, struct render_buffer *buffer); 161 161 162 162 /*! 163 163 - * Maps the memory, sets comp_buffer::mapped to the memory. 163 163 + * Maps the memory, sets render_buffer::mapped to the memory. 164 164 */ 165 165 VkResult 166 166 - comp_buffer_map(struct vk_bundle *vk, struct comp_buffer *buffer); 166 166 + render_buffer_map(struct vk_bundle *vk, struct render_buffer *buffer); 167 167 168 168 /*! 169 169 * Unmaps the memory. 170 170 */ 171 171 void 172 172 - comp_buffer_unmap(struct vk_bundle *vk, struct comp_buffer *buffer); 172 172 + render_buffer_unmap(struct vk_bundle *vk, struct render_buffer *buffer); 173 173 174 174 /*! 175 175 * Maps the buffer, and copies the given data to the buffer. 176 176 */ 177 177 VkResult 178 178 - comp_buffer_map_and_write(struct vk_bundle *vk, struct comp_buffer *buffer, void *data, VkDeviceSize size); 178 178 + render_buffer_map_and_write(struct vk_bundle *vk, struct render_buffer *buffer, void *data, VkDeviceSize size); 179 179 180 180 /*! 181 181 * Writes the given data to the buffer, will map it temporarily if not mapped. 182 182 */ 183 183 VkResult 184 184 - comp_buffer_write(struct vk_bundle *vk, struct comp_buffer *buffer, void *data, VkDeviceSize size); 184 184 + render_buffer_write(struct vk_bundle *vk, struct render_buffer *buffer, void *data, VkDeviceSize size); 185 185 186 186 187 187 /* ··· 193 193 /*! 194 194 * Holds all pools and static resources for rendering. 195 195 */ 196 196 - struct comp_resources 196 196 + struct render_resources 197 197 { 198 198 //! Vulkan resources. 199 199 struct vk_bundle *vk; ··· 203 203 */ 204 204 205 205 //! All shaders loaded. 206 206 - struct comp_shaders *shaders; 206 206 + struct render_shaders *shaders; 207 207 208 208 209 209 /* ··· 232 232 //! Pipeline layout used for mesh. 233 233 VkPipelineLayout pipeline_layout; 234 234 235 235 - struct comp_buffer vbo; 236 236 - struct comp_buffer ibo; 235 235 + struct render_buffer vbo; 236 236 + struct render_buffer ibo; 237 237 238 238 uint32_t vertex_count; 239 239 uint32_t index_counts[2]; ··· 245 245 VkDescriptorPool descriptor_pool; 246 246 247 247 //! Info ubos, only supports two views currently. 248 248 - struct comp_buffer ubos[2]; 248 248 + struct render_buffer ubos[2]; 249 249 } mesh; 250 250 251 251 struct ··· 294 294 VkPipeline distortion_timewarp_pipeline; 295 295 296 296 //! Target info. 297 297 - struct comp_buffer ubo; 297 297 + struct render_buffer ubo; 298 298 } compute; 299 299 300 300 struct ··· 319 319 * @ingroup comp_main 320 320 */ 321 321 bool 322 322 - comp_resources_init(struct comp_resources *r, 323 323 - struct comp_shaders *shaders, 324 324 - struct vk_bundle *vk, 325 325 - struct xrt_device *xdev); 322 322 + render_resources_init(struct render_resources *r, 323 323 + struct render_shaders *shaders, 324 324 + struct vk_bundle *vk, 325 325 + struct xrt_device *xdev); 326 326 327 327 /*! 328 328 * Free all pools and static resources, does not free the struct itself. 329 329 */ 330 330 void 331 331 - comp_resources_close(struct comp_resources *r); 331 331 + render_resources_close(struct render_resources *r); 332 332 + 333 333 + 334 334 + /* 335 335 + * 336 336 + * Shared between both gfx and compute. 337 337 + * 338 338 + */ 339 339 + 340 340 + /*! 341 341 + * The pure data information about a view that the renderer is rendering to. 342 342 + */ 343 343 + struct render_viewport_data 344 344 + { 345 345 + uint32_t x, y; 346 346 + uint32_t w, h; 347 347 + }; 332 348 333 349 334 350 /* ··· 338 354 */ 339 355 340 356 /*! 341 341 - * Each rendering (@ref comp_rendering) render to one or more targets 342 342 - * (@ref comp_rendering_target_resources), each target can have one or more 343 343 - * views (@ref comp_rendering_view), this struct holds all the data that is 357 357 + * Each rendering (@ref render_gfx 358 358 + ) render to one or more targets 359 359 + * (@ref render_gfx_target_resources), each target can have one or more 360 360 + * views (@ref render_gfx_view), this struct holds all the data that is 344 361 * specific to the target. 345 362 */ 346 346 - struct comp_target_data 363 363 + struct render_gfx_target_data 347 364 { 348 365 // The format that should be used to read from the target. 349 366 VkFormat format; ··· 356 373 }; 357 374 358 375 /*! 359 359 - * Each rendering (@ref comp_rendering) render to one or more targets 360 360 - * (@ref comp_rendering_target_resources), each target can have one or more 361 361 - * views (@ref comp_rendering_view), this struct holds all the vulkan resources 376 376 + * Each rendering (@ref render_gfx) render to one or more targets 377 377 + * (@ref render_gfx_target_resources), each target can have one or more 378 378 + * views (@ref render_gfx_view), this struct holds all the vulkan resources 362 379 * that is specific to the target. 363 380 * 364 381 * Technically the framebuffer could be moved out of this struct and all of this ··· 366 383 * external status of the target, but is combined to reduce the number of 367 384 * objects needed to render. 368 385 */ 369 369 - struct comp_rendering_target_resources 386 386 + struct render_gfx_target_resources 370 387 { 371 388 //! Collections of static resources. 372 372 - struct comp_resources *r; 389 389 + struct render_resources *r; 373 390 374 391 //! The data for this target. 375 375 - struct comp_target_data data; 392 392 + struct render_gfx_target_data data; 376 393 377 394 //! Render pass used for rendering, does not depend on framebuffer. 378 395 VkRenderPass render_pass; ··· 392 409 * Init a target resource struct, caller has to keep target alive until closed. 393 410 */ 394 411 bool 395 395 - comp_rendering_target_resources_init(struct comp_rendering_target_resources *rtr, 396 396 - struct comp_resources *r, 397 397 - VkImageView target, 398 398 - struct comp_target_data *data); 412 412 + render_gfx_target_resources_init(struct render_gfx_target_resources *rtr, 413 413 + struct render_resources *r, 414 414 + VkImageView target, 415 415 + struct render_gfx_target_data *data); 399 416 400 417 /*! 401 418 * Frees all resources held by the target, does not free the struct itself. 402 419 */ 403 420 void 404 404 - comp_rendering_target_resources_close(struct comp_rendering_target_resources *rtr); 421 421 + render_gfx_target_resources_close(struct render_gfx_target_resources *rtr); 405 422 406 423 407 424 /* ··· 411 428 */ 412 429 413 430 /*! 414 414 - * Each rendering (@ref comp_rendering) render to one or more targets 415 415 - * (@ref comp_rendering_target_resources), each target can have one or more 416 416 - * views (@ref comp_rendering_view), this struct holds all the vulkan resources 431 431 + * Each rendering (@ref render_gfx) render to one or more targets 432 432 + * (@ref render_gfx_target_resources), each target can have one or more 433 433 + * views (@ref render_gfx_view), this struct holds all the vulkan resources 417 434 * that is specific to the view. 418 435 */ 419 419 - struct comp_rendering_view 436 436 + struct render_gfx_view 420 437 { 421 438 struct 422 439 { ··· 428 445 * A rendering is used to create command buffers needed to do one frame of 429 446 * compositor rendering, it holds onto resources used by the command buffer. 430 447 */ 431 431 - struct comp_rendering 448 448 + struct render_gfx 432 449 { 433 450 //! Resources that we are based on. 434 434 - struct comp_resources *r; 451 451 + struct render_resources *r; 435 452 436 453 //! The current target we are rendering too, can change during command building. 437 437 - struct comp_rendering_target_resources *rtr; 454 454 + struct render_gfx_target_resources *rtr; 438 455 439 456 //! Command buffer where all commands are recorded. 440 457 VkCommandBuffer cmd; 441 458 442 459 //! Holds per view data. 443 443 - struct comp_rendering_view views[2]; 460 460 + struct render_gfx_view views[2]; 444 461 445 462 //! The current view we are rendering to. 446 463 uint32_t current_view; ··· 450 467 * Init struct and create resources needed for rendering. 451 468 */ 452 469 bool 453 453 - comp_rendering_init(struct comp_rendering *rr, struct comp_resources *r); 470 470 + render_gfx_init(struct render_gfx *rr, struct render_resources *r); 454 471 455 472 /*! 456 473 * Frees any unneeded resources and ends the command buffer so it can be used. 457 474 */ 458 475 void 459 459 - comp_rendering_finalize(struct comp_rendering *rr); 476 476 + render_gfx_finalize(struct render_gfx *rr); 460 477 461 478 /*! 462 479 * Frees all resources held by the rendering, does not free the struct itself. 463 480 */ 464 481 void 465 465 - comp_rendering_close(struct comp_rendering *rr); 482 482 + render_gfx_close(struct render_gfx *rr); 466 483 467 484 468 485 /* ··· 472 489 */ 473 490 474 491 /*! 475 475 - * The pure data information about a view that the renderer is rendering to. 476 476 - */ 477 477 - struct comp_viewport_data 478 478 - { 479 479 - uint32_t x, y; 480 480 - uint32_t w, h; 481 481 - }; 482 482 - 483 483 - /*! 484 492 * UBO data that is sent to the mesh shaders. 485 493 */ 486 486 - struct comp_mesh_ubo_data 494 494 + struct render_gfx_mesh_ubo_data 487 495 { 488 496 struct xrt_matrix_2x2 vertex_rot; 489 497 ··· 493 501 /*! 494 502 * This function allocates everything to start a single rendering. This is the 495 503 * first function you call when you start rendering, you follow up with a call 496 496 - * to comp_draw_begin_view. 504 504 + * to render_gfx_begin_view. 497 505 */ 498 506 bool 499 499 - comp_draw_begin_target(struct comp_rendering *rr, struct comp_rendering_target_resources *rtr); 507 507 + render_gfx_begin_target(struct render_gfx *rr, struct render_gfx_target_resources *rtr); 500 508 501 509 void 502 502 - comp_draw_end_target(struct comp_rendering *rr); 510 510 + render_gfx_end_target(struct render_gfx *rr); 503 511 504 512 void 505 505 - comp_draw_begin_view(struct comp_rendering *rr, uint32_t view, struct comp_viewport_data *viewport_data); 513 513 + render_gfx_begin_view(struct render_gfx *rr, uint32_t view, struct render_viewport_data *viewport_data); 506 514 507 515 void 508 508 - comp_draw_end_view(struct comp_rendering *rr); 516 516 + render_gfx_end_view(struct render_gfx *rr); 509 517 510 518 void 511 511 - comp_draw_distortion(struct comp_rendering *rr); 519 519 + render_gfx_distortion(struct render_gfx *rr); 512 520 513 521 514 522 /* ··· 518 526 */ 519 527 520 528 void 521 521 - comp_draw_update_distortion(struct comp_rendering *rr, 522 522 - uint32_t view, 523 523 - VkSampler sampler, 524 524 - VkImageView image_view, 525 525 - struct comp_mesh_ubo_data *data); 529 529 + render_gfx_update_distortion(struct render_gfx *rr, 530 530 + uint32_t view, 531 531 + VkSampler sampler, 532 532 + VkImageView image_view, 533 533 + struct render_gfx_mesh_ubo_data *data); 526 534 527 535 528 536 ··· 537 545 * of compositor rendering using compute shaders, it holds onto resources used 538 546 * by the command buffer. 539 547 */ 540 540 - struct comp_rendering_compute 548 548 + struct render_compute 541 549 { 542 550 //! Shared resources. 543 543 - struct comp_resources *r; 551 551 + struct render_resources *r; 544 552 545 553 //! Command buffer where all commands are recorded. 546 554 VkCommandBuffer cmd; ··· 552 560 /*! 553 561 * UBO data that is sent to the compute distortion shaders. 554 562 */ 555 555 - struct comp_ubo_compute_data 563 563 + struct render_compute_distortion_ubo_data 564 564 + 556 565 { 557 557 - struct comp_viewport_data views[2]; 566 566 + struct render_viewport_data views[2]; 558 567 struct xrt_normalized_rect pre_transforms[2]; 559 568 struct xrt_normalized_rect post_transforms[2]; 560 569 struct xrt_matrix_4x4 transforms[2]; ··· 564 573 * Init struct and create resources needed for compute rendering. 565 574 */ 566 575 bool 567 567 - comp_rendering_compute_init(struct comp_rendering_compute *crc, struct comp_resources *r); 576 576 + render_compute_init(struct render_compute *crc, struct render_resources *r); 568 577 569 578 /*! 570 579 * Frees all resources held by the compute rendering, does not free the struct itself. 571 580 */ 572 581 void 573 573 - comp_rendering_compute_close(struct comp_rendering_compute *crc); 582 582 + render_compute_close(struct render_compute *crc); 574 583 575 584 bool 576 576 - comp_rendering_compute_begin(struct comp_rendering_compute *crc); 585 585 + render_compute_begin(struct render_compute *crc); 577 586 578 587 void 579 579 - comp_rendering_compute_projection_timewarp(struct comp_rendering_compute *crc, 580 580 - VkSampler src_samplers[2], 581 581 - VkImageView src_image_views[2], 582 582 - const struct xrt_normalized_rect src_rects[2], 583 583 - const struct xrt_pose src_poses[2], 584 584 - const struct xrt_fov src_fovs[2], 585 585 - const struct xrt_pose new_poses[2], 586 586 - VkImage target_image, 587 587 - VkImageView target_image_view, 588 588 - const struct comp_viewport_data views[2]); 588 588 + render_compute_projection_timewarp(struct render_compute *crc, 589 589 + VkSampler src_samplers[2], 590 590 + VkImageView src_image_views[2], 591 591 + const struct xrt_normalized_rect src_rects[2], 592 592 + const struct xrt_pose src_poses[2], 593 593 + const struct xrt_fov src_fovs[2], 594 594 + const struct xrt_pose new_poses[2], 595 595 + VkImage target_image, 596 596 + VkImageView target_image_view, 597 597 + const struct render_viewport_data views[2]); 589 598 590 599 void 591 591 - comp_rendering_compute_projection(struct comp_rendering_compute *crc, // 592 592 - VkSampler src_samplers[2], // 593 593 - VkImageView src_image_views[2], // 594 594 - const struct xrt_normalized_rect src_rects[2], // 595 595 - VkImage target_image, // 596 596 - VkImageView target_image_view, // 597 597 - const struct comp_viewport_data views[2]); // 600 600 + render_compute_projection(struct render_compute *crc, // 601 601 + VkSampler src_samplers[2], // 602 602 + VkImageView src_image_views[2], // 603 603 + const struct xrt_normalized_rect src_rects[2], // 604 604 + VkImage target_image, // 605 605 + VkImageView target_image_view, // 606 606 + const struct render_viewport_data views[2]); // 598 607 599 608 void 600 600 - comp_rendering_compute_clear(struct comp_rendering_compute *crc, // 601 601 - VkImage target_image, // 602 602 - VkImageView target_image_view, // 603 603 - const struct comp_viewport_data views[2]); // 609 609 + render_compute_clear(struct render_compute *crc, // 610 610 + VkImage target_image, // 611 611 + VkImageView target_image_view, // 612 612 + const struct render_viewport_data views[2]); // 604 613 605 614 bool 606 606 - comp_rendering_compute_end(struct comp_rendering_compute *crc); 615 615 + render_compute_end(struct render_compute *crc); 607 616 608 617 609 618 /*!

+28 -28

src/xrt/compositor/render/comp_rendering.c

reviewed

··· 40 40 } 41 41 42 42 /*! 43 43 - * Get the @ref vk_bundle from @ref comp_rendering_target_resources. 43 43 + * Get the @ref vk_bundle from @ref render_gfx_target_resources. 44 44 */ 45 45 static inline struct vk_bundle * 46 46 - vk_from_rtr(struct comp_rendering_target_resources *rtr) 46 46 + vk_from_rtr(struct render_gfx_target_resources *rtr) 47 47 { 48 48 return rtr->r->vk; 49 49 } 50 50 51 51 /*! 52 52 - * Get the @ref vk_bundle from @ref comp_rendering. 52 52 + * Get the @ref vk_bundle from @ref render_gfx. 53 53 */ 54 54 static inline struct vk_bundle * 55 55 - vk_from_rr(struct comp_rendering *rr) 55 55 + vk_from_rr(struct render_gfx *rr) 56 56 { 57 57 return rr->r->vk; 58 58 } ··· 436 436 */ 437 437 438 438 bool 439 439 - comp_rendering_target_resources_init(struct comp_rendering_target_resources *rtr, 440 440 - struct comp_resources *r, 441 441 - VkImageView target, 442 442 - struct comp_target_data *data) 439 439 + render_gfx_target_resources_init(struct render_gfx_target_resources *rtr, 440 440 + struct render_resources *r, 441 441 + VkImageView target, 442 442 + struct render_gfx_target_data *data) 443 443 { 444 444 struct vk_bundle *vk = r->vk; 445 445 rtr->r = r; ··· 475 475 } 476 476 477 477 void 478 478 - comp_rendering_target_resources_close(struct comp_rendering_target_resources *rtr) 478 478 + render_gfx_target_resources_close(struct render_gfx_target_resources *rtr) 479 479 { 480 480 struct vk_bundle *vk = vk_from_rtr(rtr); 481 481 ··· 492 492 */ 493 493 494 494 bool 495 495 - comp_rendering_init(struct comp_rendering *rr, struct comp_resources *r) 495 495 + render_gfx_init(struct render_gfx *rr, struct render_resources *r) 496 496 { 497 497 struct vk_bundle *vk = r->vk; 498 498 rr->r = r; ··· 527 527 } 528 528 529 529 void 530 530 - comp_rendering_finalize(struct comp_rendering *rr) 530 530 + render_gfx_finalize(struct render_gfx *rr) 531 531 { 532 532 struct vk_bundle *vk = vk_from_rr(rr); 533 533 ··· 535 535 } 536 536 537 537 void 538 538 - comp_rendering_close(struct comp_rendering *rr) 538 538 + render_gfx_close(struct render_gfx *rr) 539 539 { 540 540 struct vk_bundle *vk = vk_from_rr(rr); 541 541 - struct comp_resources *r = rr->r; 541 541 + struct render_resources *r = rr->r; 542 542 543 543 vk_destroy_command_buffer(vk, rr->cmd); 544 544 rr->cmd = VK_NULL_HANDLE; ··· 563 563 */ 564 564 565 565 bool 566 566 - comp_draw_begin_target(struct comp_rendering *rr, struct comp_rendering_target_resources *rtr) 566 566 + render_gfx_begin_target(struct render_gfx *rr, struct render_gfx_target_resources *rtr) 567 567 { 568 568 struct vk_bundle *vk = vk_from_rr(rr); 569 569 ··· 582 582 } 583 583 584 584 void 585 585 - comp_draw_end_target(struct comp_rendering *rr) 585 585 + render_gfx_end_target(struct render_gfx *rr) 586 586 { 587 587 struct vk_bundle *vk = vk_from_rr(rr); 588 588 ··· 594 594 } 595 595 596 596 void 597 597 - comp_draw_begin_view(struct comp_rendering *rr, uint32_t view, struct comp_viewport_data *viewport_data) 597 597 + render_gfx_begin_view(struct render_gfx *rr, uint32_t view, struct render_viewport_data *viewport_data) 598 598 { 599 599 struct vk_bundle *vk = vk_from_rr(rr); 600 600 ··· 647 647 } 648 648 649 649 void 650 650 - comp_draw_end_view(struct comp_rendering *rr) 650 650 + render_gfx_end_view(struct render_gfx *rr) 651 651 { 652 652 //! Must have a current target. 653 653 assert(rr->rtr != NULL); 654 654 } 655 655 656 656 void 657 657 - comp_draw_distortion(struct comp_rendering *rr) 657 657 + render_gfx_distortion(struct render_gfx *rr) 658 658 { 659 659 struct vk_bundle *vk = vk_from_rr(rr); 660 660 - struct comp_resources *r = rr->r; 660 660 + struct render_resources *r = rr->r; 661 661 662 662 uint32_t view = rr->current_view; 663 663 - struct comp_rendering_view *v = &rr->views[view]; 663 663 + struct render_gfx_view *v = &rr->views[view]; 664 664 665 665 /* 666 666 * Descriptors and pipeline. ··· 728 728 } 729 729 730 730 void 731 731 - comp_draw_update_distortion(struct comp_rendering *rr, 732 732 - uint32_t view_index, 733 733 - VkSampler sampler, 734 734 - VkImageView image_view, 735 735 - struct comp_mesh_ubo_data *data) 731 731 + render_gfx_update_distortion(struct render_gfx *rr, 732 732 + uint32_t view_index, 733 733 + VkSampler sampler, 734 734 + VkImageView image_view, 735 735 + struct render_gfx_mesh_ubo_data *data) 736 736 { 737 737 struct vk_bundle *vk = vk_from_rr(rr); 738 738 - struct comp_resources *r = rr->r; 739 739 - struct comp_rendering_view *v = &rr->views[view_index]; 738 738 + struct render_resources *r = rr->r; 739 739 + struct render_gfx_view *v = &rr->views[view_index]; 740 740 741 741 - comp_buffer_write(vk, &r->mesh.ubos[view_index], data, sizeof(struct comp_mesh_ubo_data)); 741 741 + render_buffer_write(vk, &r->mesh.ubos[view_index], data, sizeof(struct render_gfx_mesh_ubo_data)); 742 742 743 743 update_mesh_discriptor_set( // 744 744 vk, // vk_bundle

+61 -61

src/xrt/compositor/render/comp_resources.c

reviewed

··· 89 89 90 90 static bool 91 91 init_mesh_vertex_buffers(struct vk_bundle *vk, 92 92 - struct comp_buffer *vbo, 93 93 - struct comp_buffer *ibo, 92 92 + struct render_buffer *vbo, 93 93 + struct render_buffer *ibo, 94 94 uint32_t vertex_count, 95 95 uint32_t stride, 96 96 void *vertices, ··· 113 113 return true; 114 114 } 115 115 116 116 - C(comp_buffer_init(vk, // vk_bundle 117 117 - vbo, // buffer 118 118 - vbo_usage_flags, // usage_flags 119 119 - memory_property_flags, // memory_property_flags 120 120 - vbo_size)); // size 116 116 + C(render_buffer_init(vk, // vk_bundle 117 117 + vbo, // buffer 118 118 + vbo_usage_flags, // usage_flags 119 119 + memory_property_flags, // memory_property_flags 120 120 + vbo_size)); // size 121 121 122 122 - C(comp_buffer_write(vk, // vk_bundle 123 123 - vbo, // buffer 124 124 - vertices, // data 125 125 - vbo_size)); // size 122 122 + C(render_buffer_write(vk, // vk_bundle 123 123 + vbo, // buffer 124 124 + vertices, // data 125 125 + vbo_size)); // size 126 126 127 127 128 128 // Don't create index buffer if size is zero. ··· 130 130 return true; 131 131 } 132 132 133 133 - C(comp_buffer_init(vk, // vk_bundle 134 134 - ibo, // buffer 135 135 - ibo_usage_flags, // usage_flags 136 136 - memory_property_flags, // memory_property_flags 137 137 - ibo_size)); // size 133 133 + C(render_buffer_init(vk, // vk_bundle 134 134 + ibo, // buffer 135 135 + ibo_usage_flags, // usage_flags 136 136 + memory_property_flags, // memory_property_flags 137 137 + ibo_size)); // size 138 138 139 139 - C(comp_buffer_write(vk, // vk_bundle 140 140 - ibo, // buffer 141 141 - indices, // data 142 142 - ibo_size)); // size 139 139 + C(render_buffer_write(vk, // vk_bundle 140 140 + ibo, // buffer 141 141 + indices, // data 142 142 + ibo_size)); // size 143 143 144 144 return true; 145 145 } 146 146 147 147 static bool 148 148 - init_mesh_ubo_buffers(struct vk_bundle *vk, struct comp_buffer *l_ubo, struct comp_buffer *r_ubo) 148 148 + init_mesh_ubo_buffers(struct vk_bundle *vk, struct render_buffer *l_ubo, struct render_buffer *r_ubo) 149 149 { 150 150 // Using the same flags for all ubos. 151 151 VkBufferUsageFlags ubo_usage_flags = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; ··· 153 153 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; 154 154 155 155 // Distortion ubo size. 156 156 - VkDeviceSize ubo_size = sizeof(struct comp_mesh_ubo_data); 156 156 + VkDeviceSize ubo_size = sizeof(struct render_gfx_mesh_ubo_data); 157 157 158 158 - C(comp_buffer_init(vk, // 159 159 - l_ubo, // 160 160 - ubo_usage_flags, // 161 161 - memory_property_flags, // 162 162 - ubo_size)); // size 163 163 - C(comp_buffer_map(vk, l_ubo)); 158 158 + C(render_buffer_init(vk, // 159 159 + l_ubo, // 160 160 + ubo_usage_flags, // 161 161 + memory_property_flags, // 162 162 + ubo_size)); // size 163 163 + C(render_buffer_map(vk, l_ubo)); 164 164 165 165 - C(comp_buffer_init(vk, // 166 166 - r_ubo, // 167 167 - ubo_usage_flags, // 168 168 - memory_property_flags, // 169 169 - ubo_size)); // size 170 170 - C(comp_buffer_map(vk, r_ubo)); 165 165 + C(render_buffer_init(vk, // 166 166 + r_ubo, // 167 167 + ubo_usage_flags, // 168 168 + memory_property_flags, // 169 169 + ubo_size)); // size 170 170 + C(render_buffer_map(vk, r_ubo)); 171 171 172 172 173 173 return true; ··· 418 418 static XRT_MAYBE_UNUSED VkResult 419 419 create_and_file_in_distortion_buffer_for_view(struct vk_bundle *vk, 420 420 struct xrt_device *xdev, 421 421 - struct comp_buffer *r_buffer, 422 422 - struct comp_buffer *g_buffer, 423 423 - struct comp_buffer *b_buffer, 421 421 + struct render_buffer *r_buffer, 422 422 + struct render_buffer *g_buffer, 423 423 + struct render_buffer *b_buffer, 424 424 uint32_t view) 425 425 { 426 426 VkBufferUsageFlags usage_flags = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; ··· 429 429 430 430 VkDeviceSize size = sizeof(struct texture); 431 431 432 432 - C(comp_buffer_init(vk, r_buffer, usage_flags, properties, size)); 433 433 - C(comp_buffer_init(vk, g_buffer, usage_flags, properties, size)); 434 434 - C(comp_buffer_init(vk, b_buffer, usage_flags, properties, size)); 432 432 + C(render_buffer_init(vk, r_buffer, usage_flags, properties, size)); 433 433 + C(render_buffer_init(vk, g_buffer, usage_flags, properties, size)); 434 434 + C(render_buffer_init(vk, b_buffer, usage_flags, properties, size)); 435 435 436 436 - C(comp_buffer_map(vk, r_buffer)); 437 437 - C(comp_buffer_map(vk, g_buffer)); 438 438 - C(comp_buffer_map(vk, b_buffer)); 436 436 + C(render_buffer_map(vk, r_buffer)); 437 437 + C(render_buffer_map(vk, g_buffer)); 438 438 + C(render_buffer_map(vk, b_buffer)); 439 439 440 440 struct texture *r = r_buffer->mapped; 441 441 struct texture *g = g_buffer->mapped; ··· 459 459 } 460 460 } 461 461 462 462 - comp_buffer_unmap(vk, r_buffer); 463 463 - comp_buffer_unmap(vk, g_buffer); 464 464 - comp_buffer_unmap(vk, b_buffer); 462 462 + render_buffer_unmap(vk, r_buffer); 463 463 + render_buffer_unmap(vk, g_buffer); 464 464 + render_buffer_unmap(vk, b_buffer); 465 465 466 466 return VK_SUCCESS; 467 467 } ··· 473 473 */ 474 474 475 475 bool 476 476 - comp_resources_init(struct comp_resources *r, 477 477 - struct comp_shaders *shaders, 478 478 - struct vk_bundle *vk, 479 479 - struct xrt_device *xdev) 476 476 + render_resources_init(struct render_resources *r, 477 477 + struct render_shaders *shaders, 478 478 + struct vk_bundle *vk, 479 479 + struct xrt_device *xdev) 480 480 { 481 481 /* 482 482 * Main pointers. ··· 657 657 VkMemoryPropertyFlags memory_property_flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | 658 658 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | 659 659 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; 660 660 - size_t ubo_size = sizeof(struct comp_ubo_compute_data); 660 660 + size_t ubo_size = sizeof(struct render_compute_distortion_ubo_data); 661 661 662 662 - C(comp_buffer_init( // 662 662 + C(render_buffer_init( // 663 663 vk, // vk_bundle 664 664 &r->compute.ubo, // buffer 665 665 ubo_usage_flags, // usage_flags 666 666 memory_property_flags, // memory_property_flags 667 667 ubo_size)); // size 668 668 - C(comp_buffer_map( // 668 668 + C(render_buffer_map( // 669 669 vk, // vk_bundle 670 670 &r->compute.ubo)); // buffer 671 671 672 672 673 673 - struct comp_buffer buffers[COMP_DISTORTION_NUM_IMAGES]; 673 673 + struct render_buffer buffers[COMP_DISTORTION_NUM_IMAGES]; 674 674 675 675 calc_uv_to_tanangle(xdev, 0, &r->distortion.uv_to_tanangle[0]); 676 676 calc_uv_to_tanangle(xdev, 1, &r->distortion.uv_to_tanangle[1]); ··· 698 698 os_mutex_unlock(&vk->queue_mutex); 699 699 700 700 for (uint32_t i = 0; i < ARRAY_SIZE(buffers); i++) { 701 701 - comp_buffer_close(vk, &buffers[i]); 701 701 + render_buffer_close(vk, &buffers[i]); 702 702 } 703 703 704 704 ··· 712 712 } 713 713 714 714 void 715 715 - comp_resources_close(struct comp_resources *r) 715 715 + render_resources_close(struct render_resources *r) 716 716 { 717 717 // We were never initialised or already closed, always safe to call this function. 718 718 if (r->vk == NULL) { ··· 728 728 D(PipelineLayout, r->mesh.pipeline_layout); 729 729 D(PipelineCache, r->pipeline_cache); 730 730 D(DescriptorPool, r->mesh.descriptor_pool); 731 731 - comp_buffer_close(vk, &r->mesh.vbo); 732 732 - comp_buffer_close(vk, &r->mesh.ibo); 733 733 - comp_buffer_close(vk, &r->mesh.ubos[0]); 734 734 - comp_buffer_close(vk, &r->mesh.ubos[1]); 731 731 + render_buffer_close(vk, &r->mesh.vbo); 732 732 + render_buffer_close(vk, &r->mesh.ibo); 733 733 + render_buffer_close(vk, &r->mesh.ubos[0]); 734 734 + render_buffer_close(vk, &r->mesh.ubos[1]); 735 735 736 736 D(DescriptorPool, r->compute.descriptor_pool); 737 737 D(DescriptorSetLayout, r->compute.descriptor_set_layout); ··· 749 749 for (uint32_t i = 0; i < ARRAY_SIZE(r->distortion.images); i++) { 750 750 DF(Memory, r->distortion.device_memories[i]); 751 751 } 752 752 - comp_buffer_close(vk, &r->compute.ubo); 752 752 + render_buffer_close(vk, &r->compute.ubo); 753 753 754 754 // Finally forget about the vk bundle. We do not own it! 755 755 r->vk = NULL;

+3 -4

src/xrt/compositor/render/comp_shaders.c

reviewed

··· 44 44 45 45 static VkResult 46 46 shader_load(struct vk_bundle *vk, const uint32_t *code, size_t size, VkShaderModule *out_module) 47 47 - 48 47 { 49 48 VkResult ret; 50 49 ··· 73 72 do { \ 74 73 VkResult ret = c; \ 75 74 if (ret != VK_SUCCESS) { \ 76 76 - comp_shaders_close(s, vk); \ 75 75 + render_shaders_close(s, vk); \ 77 76 return false; \ 78 77 } \ 79 78 } while (false) 80 79 81 80 bool 82 82 - comp_shaders_load(struct comp_shaders *s, struct vk_bundle *vk) 81 81 + render_shaders_load(struct render_shaders *s, struct vk_bundle *vk) 83 82 { 84 83 C(shader_load(vk, // vk_bundle 85 84 shaders_clear_comp, // data ··· 144 143 } 145 144 146 145 void 147 147 - comp_shaders_close(struct comp_shaders *s, struct vk_bundle *vk) 146 146 + render_shaders_close(struct render_shaders *s, struct vk_bundle *vk) 148 147 { 149 148 D(clear_comp); 150 149 D(distortion_comp);

+4 -4

src/xrt/compositor/render/comp_util.c

reviewed

··· 71 71 } 72 72 73 73 void 74 74 - comp_calc_time_warp_matrix(const struct xrt_pose *src_pose, 75 75 - const struct xrt_fov *src_fov, 76 76 - const struct xrt_pose *new_pose, 77 77 - struct xrt_matrix_4x4 *matrix) 74 74 + render_calc_time_warp_matrix(const struct xrt_pose *src_pose, 75 75 + const struct xrt_fov *src_fov, 76 76 + const struct xrt_pose *new_pose, 77 77 + struct xrt_matrix_4x4 *matrix) 78 78 { 79 79 // Src projection matrix. 80 80 struct xrt_matrix_4x4_f64 src_proj;