c/render: Renames and comment cleanup to improve readability.

The open source OpenXR runtime

Banish "crc" and "rr" as leftover artifacts of old names.

Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2380>

Rylie Pavlik 1 year ago 098f97ad 9d448cfb

+168 -163

2 changed files

expand all

unified split

src

xrt

compositor

render

render_gfx.c

render_interface.h

+123 -120

src/xrt/compositor/render/render_gfx.c

··· 34 34 * Get the @ref vk_bundle from @ref render_gfx. 35 35 */ 36 36 static inline struct vk_bundle * 37 - vk_from_rr(struct render_gfx *rr) 37 + vk_from_rr(struct render_gfx *render) 38 38 { 39 - return rr->r->vk; 39 + return render->r->vk; 40 40 } 41 41 42 42 XRT_CHECK_RESULT static VkResult ··· 235 235 /// Sub-allocate a UBO for our layer-specific data, 236 236 /// and create a descriptor set for it and the layer image to sample. 237 237 XRT_CHECK_RESULT static VkResult 238 - do_ubo_and_src_alloc_and_write(struct render_gfx *rr, 238 + do_ubo_and_src_alloc_and_write(struct render_gfx *render, 239 239 uint32_t ubo_binding, 240 240 const void *ubo_ptr, 241 241 VkDeviceSize ubo_size, ··· 248 248 { 249 249 VkDescriptorSet descriptor_set = VK_NULL_HANDLE; 250 250 struct render_sub_alloc ubo = XRT_STRUCT_INIT; 251 - struct vk_bundle *vk = vk_from_rr(rr); 251 + struct vk_bundle *vk = vk_from_rr(render); 252 252 253 253 VkResult ret; 254 254 ··· 258 258 */ 259 259 ret = render_sub_alloc_ubo_alloc_and_write( // 260 260 vk, // vk_bundle 261 - &rr->ubo_tracker, // rsat 261 + &render->ubo_tracker, // rsat 262 262 ubo_ptr, // ptr 263 263 ubo_size, // size 264 264 &ubo); // out_rsa ··· 293 293 } 294 294 295 295 static inline void 296 - dispatch_no_vbo(struct render_gfx *rr, uint32_t vertex_count, VkPipeline pipeline, VkDescriptorSet descriptor_set) 296 + dispatch_no_vbo(struct render_gfx *render, uint32_t vertex_count, VkPipeline pipeline, VkDescriptorSet descriptor_set) 297 297 { 298 - struct vk_bundle *vk = vk_from_rr(rr); 299 - struct render_resources *r = rr->r; 298 + struct vk_bundle *vk = vk_from_rr(render); 299 + struct render_resources *r = render->r; 300 300 301 301 302 302 VkDescriptorSet descriptor_sets[1] = {descriptor_set}; ··· 957 957 */ 958 958 959 959 bool 960 - render_gfx_init(struct render_gfx *rr, struct render_resources *r) 960 + render_gfx_init(struct render_gfx *render, struct render_resources *r) 961 961 { 962 962 // Init fields. 963 - rr->r = r; 963 + render->r = r; 964 964 965 965 // Used to sub-allocate UBOs from, restart from scratch each frame. 966 - render_sub_alloc_tracker_init(&rr->ubo_tracker, &r->gfx.shared_ubo); 966 + render_sub_alloc_tracker_init(&render->ubo_tracker, &r->gfx.shared_ubo); 967 967 968 968 return true; 969 969 } 970 970 971 971 bool 972 - render_gfx_begin(struct render_gfx *rr) 972 + render_gfx_begin(struct render_gfx *render) 973 973 { 974 - struct vk_bundle *vk = vk_from_rr(rr); 974 + struct vk_bundle *vk = vk_from_rr(render); 975 975 VkResult ret; 976 976 977 - ret = vk->vkResetCommandPool(vk->device, rr->r->cmd_pool, 0); 977 + ret = vk->vkResetCommandPool(vk->device, render->r->cmd_pool, 0); 978 978 VK_CHK_WITH_RET(ret, "vkResetCommandPool", false); 979 979 980 980 ··· 984 984 }; 985 985 986 986 ret = vk->vkBeginCommandBuffer( // 987 - rr->r->cmd, // commandBuffer 987 + render->r->cmd, // commandBuffer 988 988 &begin_info); // pBeginInfo 989 989 VK_CHK_WITH_RET(ret, "vkResetCommandPool", false); 990 990 991 - vk->vkCmdResetQueryPool( // 992 - rr->r->cmd, // commandBuffer 993 - rr->r->query_pool, // queryPool 994 - 0, // firstQuery 995 - 2); // queryCount 991 + vk->vkCmdResetQueryPool( // 992 + render->r->cmd, // commandBuffer 993 + render->r->query_pool, // queryPool 994 + 0, // firstQuery 995 + 2); // queryCount 996 996 997 997 vk->vkCmdWriteTimestamp( // 998 - rr->r->cmd, // commandBuffer 998 + render->r->cmd, // commandBuffer 999 999 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // pipelineStage 1000 - rr->r->query_pool, // queryPool 1000 + render->r->query_pool, // queryPool 1001 1001 0); // query 1002 1002 1003 1003 return true; 1004 1004 } 1005 1005 1006 1006 bool 1007 - render_gfx_end(struct render_gfx *rr) 1007 + render_gfx_end(struct render_gfx *render) 1008 1008 { 1009 - struct vk_bundle *vk = vk_from_rr(rr); 1009 + struct vk_bundle *vk = vk_from_rr(render); 1010 1010 VkResult ret; 1011 1011 1012 1012 vk->vkCmdWriteTimestamp( // 1013 - rr->r->cmd, // commandBuffer 1013 + render->r->cmd, // commandBuffer 1014 1014 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, // pipelineStage 1015 - rr->r->query_pool, // queryPool 1015 + render->r->query_pool, // queryPool 1016 1016 1); // query 1017 1017 1018 - ret = vk->vkEndCommandBuffer(rr->r->cmd); 1018 + ret = vk->vkEndCommandBuffer(render->r->cmd); 1019 1019 VK_CHK_WITH_RET(ret, "vkEndCommandBuffer", false); 1020 1020 1021 1021 return true; 1022 1022 } 1023 1023 1024 1024 void 1025 - render_gfx_fini(struct render_gfx *rr) 1025 + render_gfx_fini(struct render_gfx *render) 1026 1026 { 1027 - struct vk_bundle *vk = vk_from_rr(rr); 1028 - struct render_resources *r = rr->r; 1027 + struct vk_bundle *vk = vk_from_rr(render); 1028 + struct render_resources *r = render->r; 1029 1029 1030 1030 // Reclaim all descriptor sets. 1031 1031 vk->vkResetDescriptorPool( // ··· 1034 1034 0); // 1035 1035 1036 1036 // This "reclaims" the allocated UBOs. 1037 - U_ZERO(rr); 1037 + U_ZERO(render); 1038 1038 } 1039 1039 1040 1040 ··· 1045 1045 */ 1046 1046 1047 1047 bool 1048 - render_gfx_begin_target(struct render_gfx *rr, struct render_gfx_target_resources *rtr, const VkClearColorValue *color) 1048 + render_gfx_begin_target(struct render_gfx *render, 1049 + struct render_gfx_target_resources *rtr, 1050 + const VkClearColorValue *color) 1049 1051 { 1050 - struct vk_bundle *vk = vk_from_rr(rr); 1052 + struct vk_bundle *vk = vk_from_rr(render); 1051 1053 1052 - assert(rr->rtr == NULL); 1053 - rr->rtr = rtr; 1054 + assert(render->rtr == NULL); 1055 + render->rtr = rtr; 1054 1056 1055 1057 VkRenderPass render_pass = rtr->rgrp->render_pass; 1056 1058 VkFramebuffer framebuffer = rtr->framebuffer; 1057 1059 VkExtent2D extent = rtr->extent; 1058 1060 1059 - begin_render_pass( // 1060 - vk, // 1061 - rr->r->cmd, // 1062 - render_pass, // 1063 - framebuffer, // 1064 - extent.width, // 1065 - extent.height, // 1066 - color); // 1061 + begin_render_pass( // 1062 + vk, // 1063 + render->r->cmd, // 1064 + render_pass, // 1065 + framebuffer, // 1066 + extent.width, // 1067 + extent.height, // 1068 + color); // 1067 1069 1068 1070 return true; 1069 1071 } 1070 1072 1071 1073 void 1072 - render_gfx_end_target(struct render_gfx *rr) 1074 + render_gfx_end_target(struct render_gfx *render) 1073 1075 { 1074 - struct vk_bundle *vk = vk_from_rr(rr); 1076 + struct vk_bundle *vk = vk_from_rr(render); 1075 1077 1076 - assert(rr->rtr != NULL); 1077 - rr->rtr = NULL; 1078 + assert(render->rtr != NULL); 1079 + render->rtr = NULL; 1078 1080 1079 1081 // Stop the [shared] render pass. 1080 - vk->vkCmdEndRenderPass(rr->r->cmd); 1082 + vk->vkCmdEndRenderPass(render->r->cmd); 1081 1083 } 1082 1084 1083 1085 void 1084 - render_gfx_begin_view(struct render_gfx *rr, uint32_t view, const struct render_viewport_data *viewport_data) 1086 + render_gfx_begin_view(struct render_gfx *render, uint32_t view, const struct render_viewport_data *viewport_data) 1085 1087 { 1086 - struct vk_bundle *vk = vk_from_rr(rr); 1088 + struct vk_bundle *vk = vk_from_rr(render); 1087 1089 1088 1090 // We currently only support two views. 1089 1091 assert(view == 0 || view == 1); 1090 - assert(rr->rtr != NULL); 1092 + assert(render->rtr != NULL); 1091 1093 1092 1094 1093 1095 /* ··· 1103 1105 .maxDepth = 1.0f, 1104 1106 }; 1105 1107 1106 - vk->vkCmdSetViewport(rr->r->cmd, // commandBuffer 1107 - 0, // firstViewport 1108 - 1, // viewportCount 1109 - &viewport); // pViewports 1108 + vk->vkCmdSetViewport(render->r->cmd, // commandBuffer 1109 + 0, // firstViewport 1110 + 1, // viewportCount 1111 + &viewport); // pViewports 1110 1112 1111 1113 /* 1112 1114 * Scissor ··· 1125 1127 }, 1126 1128 }; 1127 1129 1128 - vk->vkCmdSetScissor(rr->r->cmd, // commandBuffer 1129 - 0, // firstScissor 1130 - 1, // scissorCount 1131 - &scissor); // pScissors 1130 + vk->vkCmdSetScissor(render->r->cmd, // commandBuffer 1131 + 0, // firstScissor 1132 + 1, // scissorCount 1133 + &scissor); // pScissors 1132 1134 } 1133 1135 1134 1136 void 1135 - render_gfx_end_view(struct render_gfx *rr) 1137 + render_gfx_end_view(struct render_gfx *render) 1136 1138 { 1137 1139 //! Must have a current target. 1138 - assert(rr->rtr != NULL); 1140 + assert(render->rtr != NULL); 1139 1141 } 1140 1142 1141 1143 XRT_CHECK_RESULT VkResult 1142 - render_gfx_mesh_alloc_and_write(struct render_gfx *rr, 1144 + render_gfx_mesh_alloc_and_write(struct render_gfx *render, 1143 1145 const struct render_gfx_mesh_ubo_data *data, 1144 1146 VkSampler src_sampler, 1145 1147 VkImageView src_image_view, 1146 1148 VkDescriptorSet *out_descriptor_set) 1147 1149 { 1148 - struct render_resources *r = rr->r; 1150 + struct render_resources *r = render->r; 1149 1151 1150 1152 return do_ubo_and_src_alloc_and_write( // 1151 - rr, // rr 1153 + render, // 1152 1154 r->mesh.ubo_binding, // ubo_binding 1153 1155 data, // ubo_ptr 1154 1156 sizeof(*data), // ubo_size ··· 1161 1163 } 1162 1164 1163 1165 void 1164 - render_gfx_mesh_draw(struct render_gfx *rr, uint32_t mesh_index, VkDescriptorSet descriptor_set, bool do_timewarp) 1166 + render_gfx_mesh_draw(struct render_gfx *render, uint32_t mesh_index, VkDescriptorSet descriptor_set, bool do_timewarp) 1165 1167 { 1166 - struct vk_bundle *vk = vk_from_rr(rr); 1167 - struct render_resources *r = rr->r; 1168 + struct vk_bundle *vk = vk_from_rr(render); 1169 + struct render_resources *r = render->r; 1168 1170 1169 1171 1170 1172 /* ··· 1183 1185 NULL); // pDynamicOffsets 1184 1186 1185 1187 // Select which pipeline we want. 1186 - VkPipeline pipeline = do_timewarp ? rr->rtr->rgrp->mesh.pipeline_timewarp : rr->rtr->rgrp->mesh.pipeline; 1188 + VkPipeline pipeline = 1189 + do_timewarp ? render->rtr->rgrp->mesh.pipeline_timewarp : render->rtr->rgrp->mesh.pipeline; 1187 1190 1188 1191 vk->vkCmdBindPipeline( // 1189 1192 r->cmd, // commandBuffer ··· 1243 1246 */ 1244 1247 1245 1248 XRT_CHECK_RESULT VkResult 1246 - render_gfx_layer_cylinder_alloc_and_write(struct render_gfx *rr, 1249 + render_gfx_layer_cylinder_alloc_and_write(struct render_gfx *render, 1247 1250 const struct render_gfx_layer_cylinder_data *data, 1248 1251 VkSampler src_sampler, 1249 1252 VkImageView src_image_view, 1250 1253 VkDescriptorSet *out_descriptor_set) 1251 1254 { 1252 - struct render_resources *r = rr->r; 1255 + struct render_resources *r = render->r; 1253 1256 1254 1257 return do_ubo_and_src_alloc_and_write( // 1255 - rr, // rr 1258 + render, // 1256 1259 RENDER_BINDING_LAYER_SHARED_UBO, // ubo_binding 1257 - data, // ubo_ptr 1258 - sizeof(*data), // ubo_size 1260 + data, // 1261 + sizeof(*data), // 1259 1262 RENDER_BINDING_LAYER_SHARED_SRC, // src_binding 1260 - src_sampler, // src_sampler 1261 - src_image_view, // src_image_view 1263 + src_sampler, // 1264 + src_image_view, // 1262 1265 r->gfx.ubo_and_src_descriptor_pool, // descriptor_pool 1263 1266 r->gfx.layer.shared.descriptor_set_layout, // descriptor_set_layout 1264 1267 out_descriptor_set); // out_descriptor_set 1265 1268 } 1266 1269 1267 1270 XRT_CHECK_RESULT VkResult 1268 - render_gfx_layer_equirect2_alloc_and_write(struct render_gfx *rr, 1271 + render_gfx_layer_equirect2_alloc_and_write(struct render_gfx *render, 1269 1272 const struct render_gfx_layer_equirect2_data *data, 1270 1273 VkSampler src_sampler, 1271 1274 VkImageView src_image_view, 1272 1275 VkDescriptorSet *out_descriptor_set) 1273 1276 { 1274 - struct render_resources *r = rr->r; 1277 + struct render_resources *r = render->r; 1275 1278 1276 1279 return do_ubo_and_src_alloc_and_write( // 1277 - rr, // rr 1280 + render, // 1278 1281 RENDER_BINDING_LAYER_SHARED_UBO, // ubo_binding 1279 - data, // ubo_ptr 1280 - sizeof(*data), // ubo_size 1282 + data, // 1283 + sizeof(*data), // 1281 1284 RENDER_BINDING_LAYER_SHARED_SRC, // src_binding 1282 - src_sampler, // src_sampler 1283 - src_image_view, // src_image_view 1285 + src_sampler, // 1286 + src_image_view, // 1284 1287 r->gfx.ubo_and_src_descriptor_pool, // descriptor_pool 1285 1288 r->gfx.layer.shared.descriptor_set_layout, // descriptor_set_layout 1286 1289 out_descriptor_set); // out_descriptor_set 1287 1290 } 1288 1291 1289 1292 XRT_CHECK_RESULT VkResult 1290 - render_gfx_layer_projection_alloc_and_write(struct render_gfx *rr, 1293 + render_gfx_layer_projection_alloc_and_write(struct render_gfx *render, 1291 1294 const struct render_gfx_layer_projection_data *data, 1292 1295 VkSampler src_sampler, 1293 1296 VkImageView src_image_view, 1294 1297 VkDescriptorSet *out_descriptor_set) 1295 1298 { 1296 - struct render_resources *r = rr->r; 1299 + struct render_resources *r = render->r; 1297 1300 1298 1301 return do_ubo_and_src_alloc_and_write( // 1299 - rr, // rr 1302 + render, // 1300 1303 RENDER_BINDING_LAYER_SHARED_UBO, // ubo_binding 1301 - data, // ubo_ptr 1302 - sizeof(*data), // ubo_size 1304 + data, // 1305 + sizeof(*data), // 1303 1306 RENDER_BINDING_LAYER_SHARED_SRC, // src_binding 1304 - src_sampler, // src_sampler 1305 - src_image_view, // src_image_view 1307 + src_sampler, // 1308 + src_image_view, // 1306 1309 r->gfx.ubo_and_src_descriptor_pool, // descriptor_pool 1307 1310 r->gfx.layer.shared.descriptor_set_layout, // descriptor_set_layout 1308 1311 out_descriptor_set); // out_descriptor_set 1309 1312 } 1310 1313 1311 1314 XRT_CHECK_RESULT VkResult 1312 - render_gfx_layer_quad_alloc_and_write(struct render_gfx *rr, 1315 + render_gfx_layer_quad_alloc_and_write(struct render_gfx *render, 1313 1316 const struct render_gfx_layer_quad_data *data, 1314 1317 VkSampler src_sampler, 1315 1318 VkImageView src_image_view, 1316 1319 VkDescriptorSet *out_descriptor_set) 1317 1320 { 1318 - struct render_resources *r = rr->r; 1321 + struct render_resources *r = render->r; 1319 1322 1320 1323 return do_ubo_and_src_alloc_and_write( // 1321 - rr, // rr 1324 + render, // 1322 1325 RENDER_BINDING_LAYER_SHARED_UBO, // ubo_binding 1323 - data, // ubo_ptr 1324 - sizeof(*data), // ubo_size 1326 + data, // 1327 + sizeof(*data), // 1325 1328 RENDER_BINDING_LAYER_SHARED_SRC, // src_binding 1326 - src_sampler, // src_sampler 1327 - src_image_view, // src_image_view 1329 + src_sampler, // 1330 + src_image_view, // 1328 1331 r->gfx.ubo_and_src_descriptor_pool, // descriptor_pool 1329 1332 r->gfx.layer.shared.descriptor_set_layout, // descriptor_set_layout 1330 1333 out_descriptor_set); // out_descriptor_set 1331 1334 } 1332 1335 1333 1336 void 1334 - render_gfx_layer_cylinder(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1337 + render_gfx_layer_cylinder(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1335 1338 { 1336 - VkPipeline pipeline = // 1337 - premultiplied_alpha // 1338 - ? rr->rtr->rgrp->layer.cylinder_premultiplied_alpha // 1339 - : rr->rtr->rgrp->layer.cylinder_unpremultiplied_alpha; // 1339 + VkPipeline pipeline = // 1340 + premultiplied_alpha // 1341 + ? render->rtr->rgrp->layer.cylinder_premultiplied_alpha // 1342 + : render->rtr->rgrp->layer.cylinder_unpremultiplied_alpha; // 1340 1343 1341 1344 // One per degree. 1342 1345 uint32_t subdivisions = 360; ··· 1348 1351 uint32_t vertex_count = edges * 2; 1349 1352 1350 1353 dispatch_no_vbo( // 1351 - rr, // rr 1354 + render, // 1352 1355 vertex_count, // vertex_count 1353 1356 pipeline, // pipeline 1354 1357 descriptor_set); // descriptor_set 1355 1358 } 1356 1359 1357 1360 void 1358 - render_gfx_layer_equirect2(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1361 + render_gfx_layer_equirect2(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1359 1362 { 1360 - VkPipeline pipeline = // 1361 - premultiplied_alpha // 1362 - ? rr->rtr->rgrp->layer.equirect2_premultiplied_alpha // 1363 - : rr->rtr->rgrp->layer.equirect2_unpremultiplied_alpha; // 1363 + VkPipeline pipeline = // 1364 + premultiplied_alpha // 1365 + ? render->rtr->rgrp->layer.equirect2_premultiplied_alpha // 1366 + : render->rtr->rgrp->layer.equirect2_unpremultiplied_alpha; // 1364 1367 1365 1368 // Hardcoded to 4 vertices. 1366 1369 dispatch_no_vbo( // 1367 - rr, // rr 1370 + render, // 1368 1371 4, // vertex_count 1369 1372 pipeline, // pipeline 1370 1373 descriptor_set); // descriptor_set 1371 1374 } 1372 1375 1373 1376 void 1374 - render_gfx_layer_projection(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1377 + render_gfx_layer_projection(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1375 1378 { 1376 - VkPipeline pipeline = // 1377 - premultiplied_alpha // 1378 - ? rr->rtr->rgrp->layer.proj_premultiplied_alpha // 1379 - : rr->rtr->rgrp->layer.proj_unpremultiplied_alpha; // 1379 + VkPipeline pipeline = // 1380 + premultiplied_alpha // 1381 + ? render->rtr->rgrp->layer.proj_premultiplied_alpha // 1382 + : render->rtr->rgrp->layer.proj_unpremultiplied_alpha; // 1380 1383 1381 1384 // Hardcoded to 4 vertices. 1382 1385 dispatch_no_vbo( // 1383 - rr, // rr 1386 + render, // 1384 1387 4, // vertex_count 1385 1388 pipeline, // pipeline 1386 1389 descriptor_set); // descriptor_set 1387 1390 } 1388 1391 1389 1392 void 1390 - render_gfx_layer_quad(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1393 + render_gfx_layer_quad(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set) 1391 1394 { 1392 - VkPipeline pipeline = // 1393 - premultiplied_alpha // 1394 - ? rr->rtr->rgrp->layer.quad_premultiplied_alpha // 1395 - : rr->rtr->rgrp->layer.quad_unpremultiplied_alpha; // 1395 + VkPipeline pipeline = // 1396 + premultiplied_alpha // 1397 + ? render->rtr->rgrp->layer.quad_premultiplied_alpha // 1398 + : render->rtr->rgrp->layer.quad_unpremultiplied_alpha; // 1396 1399 1397 1400 // Hardcoded to 4 vertices. 1398 1401 dispatch_no_vbo( // 1399 - rr, // rr 1402 + render, // 1400 1403 4, // vertex_count 1401 1404 pipeline, // pipeline 1402 1405 descriptor_set); // descriptor_set

+45 -43

src/xrt/compositor/render/render_interface.h

··· 847 847 * @public @memberof render_gfx 848 848 */ 849 849 bool 850 - render_gfx_init(struct render_gfx *rr, struct render_resources *r); 850 + render_gfx_init(struct render_gfx *render, struct render_resources *r); 851 851 852 852 /*! 853 853 * Begins the rendering, takes the vk_bundle's pool lock and leaves it locked. ··· 855 855 * @public @memberof render_gfx 856 856 */ 857 857 bool 858 - render_gfx_begin(struct render_gfx *rr); 858 + render_gfx_begin(struct render_gfx *render); 859 859 860 860 /*! 861 861 * Frees any unneeded resources and ends the command buffer so it can be used, ··· 864 864 * @public @memberof render_gfx 865 865 */ 866 866 bool 867 - render_gfx_end(struct render_gfx *rr); 867 + render_gfx_end(struct render_gfx *render); 868 868 869 869 /*! 870 870 * Frees all resources held by the rendering, does not free the struct itself. ··· 872 872 * @public @memberof render_gfx 873 873 */ 874 874 void 875 - render_gfx_fini(struct render_gfx *rr); 875 + render_gfx_fini(struct render_gfx *render); 876 876 877 877 878 878 /* ··· 957 957 * @public @memberof render_gfx 958 958 */ 959 959 bool 960 - render_gfx_begin_target(struct render_gfx *rr, struct render_gfx_target_resources *rtr, const VkClearColorValue *color); 960 + render_gfx_begin_target(struct render_gfx *render, 961 + struct render_gfx_target_resources *rtr, 962 + const VkClearColorValue *color); 961 963 962 964 /*! 963 965 * @public @memberof render_gfx 964 966 */ 965 967 void 966 - render_gfx_end_target(struct render_gfx *rr); 968 + render_gfx_end_target(struct render_gfx *render); 967 969 968 970 /*! 969 971 * @public @memberof render_gfx 970 972 */ 971 973 void 972 - render_gfx_begin_view(struct render_gfx *rr, uint32_t view, const struct render_viewport_data *viewport_data); 974 + render_gfx_begin_view(struct render_gfx *render, uint32_t view, const struct render_viewport_data *viewport_data); 973 975 974 976 /*! 975 977 * @public @memberof render_gfx 976 978 */ 977 979 void 978 - render_gfx_end_view(struct render_gfx *rr); 980 + render_gfx_end_view(struct render_gfx *render); 979 981 980 982 /*! 981 983 * Allocate needed resources for one mesh shader dispatch, will also update the ··· 988 990 * @public @memberof render_gfx 989 991 */ 990 992 XRT_CHECK_RESULT VkResult 991 - render_gfx_mesh_alloc_and_write(struct render_gfx *rr, 993 + render_gfx_mesh_alloc_and_write(struct render_gfx *render, 992 994 const struct render_gfx_mesh_ubo_data *data, 993 995 VkSampler src_sampler, 994 996 VkImageView src_image_view, ··· 1001 1003 * @public @memberof render_gfx 1002 1004 */ 1003 1005 void 1004 - render_gfx_mesh_draw(struct render_gfx *rr, uint32_t mesh_index, VkDescriptorSet descriptor_set, bool do_timewarp); 1006 + render_gfx_mesh_draw(struct render_gfx *render, uint32_t mesh_index, VkDescriptorSet descriptor_set, bool do_timewarp); 1005 1007 1006 1008 /*! 1007 1009 * Allocate and write a UBO and descriptor_set to be used for cylinder layer ··· 1010 1012 * @public @memberof render_gfx 1011 1013 */ 1012 1014 XRT_CHECK_RESULT VkResult 1013 - render_gfx_layer_cylinder_alloc_and_write(struct render_gfx *rr, 1015 + render_gfx_layer_cylinder_alloc_and_write(struct render_gfx *render, 1014 1016 const struct render_gfx_layer_cylinder_data *data, 1015 1017 VkSampler src_sampler, 1016 1018 VkImageView src_image_view, ··· 1023 1025 * @public @memberof render_gfx 1024 1026 */ 1025 1027 XRT_CHECK_RESULT VkResult 1026 - render_gfx_layer_equirect2_alloc_and_write(struct render_gfx *rr, 1028 + render_gfx_layer_equirect2_alloc_and_write(struct render_gfx *render, 1027 1029 const struct render_gfx_layer_equirect2_data *data, 1028 1030 VkSampler src_sampler, 1029 1031 VkImageView src_image_view, ··· 1036 1038 * @public @memberof render_gfx 1037 1039 */ 1038 1040 XRT_CHECK_RESULT VkResult 1039 - render_gfx_layer_projection_alloc_and_write(struct render_gfx *rr, 1041 + render_gfx_layer_projection_alloc_and_write(struct render_gfx *render, 1040 1042 const struct render_gfx_layer_projection_data *data, 1041 1043 VkSampler src_sampler, 1042 1044 VkImageView src_image_view, ··· 1049 1051 * @public @memberof render_gfx 1050 1052 */ 1051 1053 XRT_CHECK_RESULT VkResult 1052 - render_gfx_layer_quad_alloc_and_write(struct render_gfx *rr, 1054 + render_gfx_layer_quad_alloc_and_write(struct render_gfx *render, 1053 1055 const struct render_gfx_layer_quad_data *data, 1054 1056 VkSampler src_sampler, 1055 1057 VkImageView src_image_view, ··· 1063 1065 * @public @memberof render_gfx 1064 1066 */ 1065 1067 void 1066 - render_gfx_layer_cylinder(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1068 + render_gfx_layer_cylinder(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1067 1069 1068 1070 /*! 1069 1071 * Dispatch a equirect2 layer shader into the current target and view, ··· 1073 1075 * @public @memberof render_gfx 1074 1076 */ 1075 1077 void 1076 - render_gfx_layer_equirect2(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1078 + render_gfx_layer_equirect2(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1077 1079 1078 1080 /*! 1079 1081 * Dispatch a projection layer shader into the current target and view, ··· 1083 1085 * @public @memberof render_gfx 1084 1086 */ 1085 1087 void 1086 - render_gfx_layer_projection(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1088 + render_gfx_layer_projection(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1087 1089 1088 1090 /*! 1089 1091 * Dispatch a quad layer shader into the current target and view, allocate ··· 1092 1094 * @public @memberof render_gfx 1093 1095 */ 1094 1096 void 1095 - render_gfx_layer_quad(struct render_gfx *rr, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1097 + render_gfx_layer_quad(struct render_gfx *render, bool premultiplied_alpha, VkDescriptorSet descriptor_set); 1096 1098 1097 1099 /*! 1098 1100 * @} ··· 1251 1253 * @public @memberof render_compute 1252 1254 */ 1253 1255 bool 1254 - render_compute_init(struct render_compute *crc, struct render_resources *r); 1256 + render_compute_init(struct render_compute *render, struct render_resources *r); 1255 1257 1256 1258 /*! 1257 1259 * Frees all resources held by the compute rendering, does not free the struct itself. ··· 1259 1261 * @public @memberof render_compute 1260 1262 */ 1261 1263 void 1262 - render_compute_fini(struct render_compute *crc); 1264 + render_compute_fini(struct render_compute *render); 1263 1265 1264 1266 /*! 1265 1267 * Begin the compute command buffer building, takes the vk_bundle's pool lock ··· 1268 1270 * @public @memberof render_compute 1269 1271 */ 1270 1272 bool 1271 - render_compute_begin(struct render_compute *crc); 1273 + render_compute_begin(struct render_compute *render); 1272 1274 1273 1275 /*! 1274 1276 * Frees any unneeded resources and ends the command buffer so it can be used, ··· 1277 1279 * @public @memberof render_compute 1278 1280 */ 1279 1281 bool 1280 - render_compute_end(struct render_compute *crc); 1282 + render_compute_end(struct render_compute *render); 1281 1283 1282 1284 /*! 1283 1285 * Updates the given @p descriptor_set and dispatches the layer shader. Unlike ··· 1292 1294 * @public @memberof render_compute 1293 1295 */ 1294 1296 void 1295 - render_compute_layers(struct render_compute *crc, // 1296 - VkDescriptorSet descriptor_set, // 1297 - VkBuffer ubo, // 1298 - VkSampler src_samplers[RENDER_MAX_IMAGES_SIZE], // 1299 - VkImageView src_image_views[RENDER_MAX_IMAGES_SIZE], // 1300 - uint32_t num_srcs, // 1301 - VkImageView target_image_view, // 1302 - const struct render_viewport_data *view, // 1303 - bool timewarp); // 1297 + render_compute_layers(struct render_compute *render, 1298 + VkDescriptorSet descriptor_set, 1299 + VkBuffer ubo, 1300 + VkSampler src_samplers[RENDER_MAX_IMAGES_SIZE], 1301 + VkImageView src_image_views[RENDER_MAX_IMAGES_SIZE], 1302 + uint32_t num_srcs, 1303 + VkImageView target_image_view, 1304 + const struct render_viewport_data *view, 1305 + bool timewarp); 1304 1306 1305 1307 /*! 1306 1308 * @public @memberof render_compute 1307 1309 */ 1308 1310 void 1309 - render_compute_projection_timewarp(struct render_compute *crc, 1311 + render_compute_projection_timewarp(struct render_compute *render, 1310 1312 VkSampler src_samplers[XRT_MAX_VIEWS], 1311 1313 VkImageView src_image_views[XRT_MAX_VIEWS], 1312 1314 const struct xrt_normalized_rect src_rects[XRT_MAX_VIEWS], ··· 1321 1323 * @public @memberof render_compute 1322 1324 */ 1323 1325 void 1324 - render_compute_projection(struct render_compute *crc, // 1325 - VkSampler src_samplers[XRT_MAX_VIEWS], // 1326 - VkImageView src_image_views[XRT_MAX_VIEWS], // 1327 - const struct xrt_normalized_rect src_rects[XRT_MAX_VIEWS], // 1328 - VkImage target_image, // 1329 - VkImageView target_image_view, // 1330 - const struct render_viewport_data views[XRT_MAX_VIEWS]); // 1326 + render_compute_projection(struct render_compute *render, 1327 + VkSampler src_samplers[XRT_MAX_VIEWS], 1328 + VkImageView src_image_views[XRT_MAX_VIEWS], 1329 + const struct xrt_normalized_rect src_rects[XRT_MAX_VIEWS], 1330 + VkImage target_image, 1331 + VkImageView target_image_view, 1332 + const struct render_viewport_data views[XRT_MAX_VIEWS]); 1331 1333 1332 1334 /*! 1333 1335 * @public @memberof render_compute 1334 1336 */ 1335 1337 void 1336 - render_compute_clear(struct render_compute *crc, // 1337 - VkImage target_image, // 1338 - VkImageView target_image_view, // 1339 - const struct render_viewport_data views[XRT_MAX_VIEWS]); // 1338 + render_compute_clear(struct render_compute *render, 1339 + VkImage target_image, 1340 + VkImageView target_image_view, 1341 + const struct render_viewport_data views[XRT_MAX_VIEWS]); 1340 1342 1341 1343 1342 1344