matrixfurry.com / monado
The open source OpenXR runtime
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

src: Consistently append 2 to equirect2 code.

Rename XRT_FEATURE_OPENXR_LAYER_EQUIRECT to XRT_FEATURE_OPENXR_LAYER_EQUIRECT2.
Rename equirect to equirect2.
Rename shader files.

authored by

Lubosz Sarnecki and committed by
Jakob Bornecrantz f334b8b6 b2337469

+138 -137
+3 -3
CMakeLists.txt
··· 144 144 if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_CYLINDER) 145 145 set(XRT_FEATURE_OPENXR_LAYER_CYLINDER ON) 146 146 endif() 147 - if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_EQUIRECT) 148 - set(XRT_FEATURE_OPENXR_LAYER_EQUIRECT ON) 147 + if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_EQUIRECT2) 148 + set(XRT_FEATURE_OPENXR_LAYER_EQUIRECT2 ON) 149 149 endif() 150 150 if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY) 151 151 set(XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY OFF) ··· 303 303 message(STATUS "# FEATURE_OPENXR_LAYER_DEPTH: ${XRT_FEATURE_OPENXR_LAYER_DEPTH}") 304 304 message(STATUS "# FEATURE_OPENXR_LAYER_CUBE: ${XRT_FEATURE_OPENXR_LAYER_CUBE}") 305 305 message(STATUS "# FEATURE_OPENXR_LAYER_CYLINDER: ${XRT_FEATURE_OPENXR_LAYER_CYLINDER}") 306 - message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT}") 306 + message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT2: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT2}") 307 307 message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY}") 308 308 message(STATUS "# FEATURE_STEAMVR_PLUGIN: ${XRT_FEATURE_STEAMVR_PLUGIN}") 309 309 message(STATUS "#")
+1 -1
scripts/generate_oxr_ext_support.py
··· 19 19 ['XR_KHR_composition_layer_cube', 'XRT_FEATURE_OPENXR_LAYER_CUBE'], 20 20 ['XR_KHR_composition_layer_cylinder', 'XRT_FEATURE_OPENXR_LAYER_CYLINDER'], 21 21 ['XR_KHR_composition_layer_equirect', 'XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY'], 22 - ['XR_KHR_composition_layer_equirect2', 'XRT_FEATURE_OPENXR_LAYER_EQUIRECT'], 22 + ['XR_KHR_composition_layer_equirect2', 'XRT_FEATURE_OPENXR_LAYER_EQUIRECT2'], 23 23 ['XR_EXT_debug_utils'], 24 24 ['XR_MND_headless'], 25 25 ['XR_MND_swapchain_usage_input_attachment_bit'],
+2 -2
src/xrt/compositor/CMakeLists.txt
··· 6 6 shaders/mesh.vert 7 7 shaders/layer.frag 8 8 shaders/layer.vert 9 - shaders/equirect.vert 10 - shaders/equirect.frag 9 + shaders/equirect2.vert 10 + shaders/equirect2.frag 11 11 ) 12 12 13 13 set(CLIENT_SOURCE_FILES)
+7 -7
src/xrt/compositor/client/comp_gl_client.c
··· 263 263 } 264 264 265 265 static xrt_result_t 266 - client_gl_compositor_layer_equirect(struct xrt_compositor *xc, 267 - struct xrt_device *xdev, 268 - struct xrt_swapchain *xsc, 269 - const struct xrt_layer_data *data) 266 + client_gl_compositor_layer_equirect2(struct xrt_compositor *xc, 267 + struct xrt_device *xdev, 268 + struct xrt_swapchain *xsc, 269 + const struct xrt_layer_data *data) 270 270 { 271 271 struct client_gl_compositor *c = client_gl_compositor(xc); 272 272 struct xrt_swapchain *xscfb; 273 273 274 - assert(data->type == XRT_LAYER_EQUIRECT); 274 + assert(data->type == XRT_LAYER_EQUIRECT2); 275 275 276 276 xscfb = &client_gl_swapchain(xsc)->xscn->base; 277 277 278 278 struct xrt_layer_data d = *data; 279 279 d.flip_y = !d.flip_y; 280 280 281 - return xrt_comp_layer_equirect(&c->xcn->base, xdev, xscfb, &d); 281 + return xrt_comp_layer_equirect2(&c->xcn->base, xdev, xscfb, &d); 282 282 } 283 283 284 284 static xrt_result_t ··· 442 442 c->base.base.layer_quad = client_gl_compositor_layer_quad; 443 443 c->base.base.layer_cube = client_gl_compositor_layer_cube; 444 444 c->base.base.layer_cylinder = client_gl_compositor_layer_cylinder; 445 - c->base.base.layer_equirect = client_gl_compositor_layer_equirect; 445 + c->base.base.layer_equirect2 = client_gl_compositor_layer_equirect2; 446 446 c->base.base.layer_commit = client_gl_compositor_layer_commit; 447 447 c->base.base.destroy = client_gl_compositor_destroy; 448 448 c->base.base.poll_events = client_gl_compositor_poll_events;
+7 -7
src/xrt/compositor/client/comp_vk_client.c
··· 330 330 } 331 331 332 332 static xrt_result_t 333 - client_vk_compositor_layer_equirect(struct xrt_compositor *xc, 334 - struct xrt_device *xdev, 335 - struct xrt_swapchain *xsc, 336 - const struct xrt_layer_data *data) 333 + client_vk_compositor_layer_equirect2(struct xrt_compositor *xc, 334 + struct xrt_device *xdev, 335 + struct xrt_swapchain *xsc, 336 + const struct xrt_layer_data *data) 337 337 { 338 338 struct client_vk_compositor *c = client_vk_compositor(xc); 339 339 struct xrt_swapchain *xscfb; 340 340 341 - assert(data->type == XRT_LAYER_EQUIRECT); 341 + assert(data->type == XRT_LAYER_EQUIRECT2); 342 342 343 343 xscfb = &client_vk_swapchain(xsc)->xscn->base; 344 344 345 - return xrt_comp_layer_equirect(&c->xcn->base, xdev, xscfb, data); 345 + return xrt_comp_layer_equirect2(&c->xcn->base, xdev, xscfb, data); 346 346 } 347 347 348 348 static xrt_result_t ··· 541 541 c->base.base.layer_quad = client_vk_compositor_layer_quad; 542 542 c->base.base.layer_cube = client_vk_compositor_layer_cube; 543 543 c->base.base.layer_cylinder = client_vk_compositor_layer_cylinder; 544 - c->base.base.layer_equirect = client_vk_compositor_layer_equirect; 544 + c->base.base.layer_equirect2 = client_vk_compositor_layer_equirect2; 545 545 c->base.base.layer_commit = client_vk_compositor_layer_commit; 546 546 c->base.base.destroy = client_vk_compositor_destroy; 547 547 c->base.base.poll_events = client_vk_compositor_poll_events;
+9 -9
src/xrt/compositor/main/comp_compositor.c
··· 441 441 } 442 442 443 443 static xrt_result_t 444 - compositor_layer_equirect(struct xrt_compositor *xc, 445 - struct xrt_device *xdev, 446 - struct xrt_swapchain *xsc, 447 - const struct xrt_layer_data *data) 444 + compositor_layer_equirect2(struct xrt_compositor *xc, 445 + struct xrt_device *xdev, 446 + struct xrt_swapchain *xsc, 447 + const struct xrt_layer_data *data) 448 448 { 449 449 return do_single(xc, xdev, xsc, data); 450 450 } ··· 513 513 image = &layer->scs[0]->images[cyl->sub.image_index]; 514 514 comp_renderer_set_cylinder_layer(c->r, i, image, data); 515 515 } break; 516 - case XRT_LAYER_EQUIRECT: { 517 - struct xrt_layer_equirect_data *eq = 518 - &layer->data.equirect; 516 + case XRT_LAYER_EQUIRECT2: { 517 + struct xrt_layer_equirect2_data *eq = 518 + &layer->data.equirect2; 519 519 struct comp_swapchain_image *image; 520 520 image = &layer->scs[0]->images[eq->sub.image_index]; 521 - comp_renderer_set_equirect_layer(c->r, i, image, data); 521 + comp_renderer_set_equirect2_layer(c->r, i, image, data); 522 522 } break; 523 523 case XRT_LAYER_CUBE: 524 524 // Should never end up here. ··· 1308 1308 c->base.base.layer_quad = compositor_layer_quad; 1309 1309 c->base.base.layer_cube = compositor_layer_cube; 1310 1310 c->base.base.layer_cylinder = compositor_layer_cylinder; 1311 - c->base.base.layer_equirect = compositor_layer_equirect; 1311 + c->base.base.layer_equirect2 = compositor_layer_equirect2; 1312 1312 c->base.base.layer_commit = compositor_layer_commit; 1313 1313 c->base.base.poll_events = compositor_poll_events; 1314 1314 c->base.base.destroy = compositor_destroy;
+2 -2
src/xrt/compositor/main/comp_compositor.h
··· 141 141 VkShaderModule mesh_vert; 142 142 VkShaderModule mesh_frag; 143 143 144 - VkShaderModule equirect_vert; 145 - VkShaderModule equirect_frag; 144 + VkShaderModule equirect2_vert; 145 + VkShaderModule equirect2_frag; 146 146 147 147 VkShaderModule layer_vert; 148 148 VkShaderModule layer_frag;
+17 -17
src/xrt/compositor/main/comp_layer.c
··· 84 84 } 85 85 86 86 static bool 87 - _init_equirect_ubo(struct comp_render_layer *self) 87 + _init_equirect2_ubo(struct comp_render_layer *self) 88 88 { 89 89 VkBufferUsageFlags usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; 90 90 VkMemoryPropertyFlags properties = ··· 93 93 VK_MEMORY_PROPERTY_HOST_CACHED_BIT; 94 94 95 95 if (!vk_buffer_init(self->vk, sizeof(struct layer_transformation), 96 - usage, properties, &self->equirect_ubo.handle, 97 - &self->equirect_ubo.memory)) 96 + usage, properties, &self->equirect2_ubo.handle, 97 + &self->equirect2_ubo.memory)) 98 98 return false; 99 99 100 100 VkResult res = self->vk->vkMapMemory( 101 - self->vk->device, self->equirect_ubo.memory, 0, VK_WHOLE_SIZE, 0, 102 - &self->equirect_ubo.data); 101 + self->vk->device, self->equirect2_ubo.memory, 0, VK_WHOLE_SIZE, 0, 102 + &self->equirect2_ubo.data); 103 103 vk_check_error("vkMapMemory", res, false); 104 104 105 - memcpy(self->equirect_ubo.data, &self->equirect_data, 106 - sizeof(struct layer_equirect_data)); 105 + memcpy(self->equirect2_ubo.data, &self->equirect2_data, 106 + sizeof(struct layer_equirect2_data)); 107 107 108 108 return true; 109 109 } ··· 188 188 } 189 189 190 190 void 191 - comp_layer_update_equirect_descriptor(struct comp_render_layer *self, 192 - struct xrt_layer_equirect_data *data) 191 + comp_layer_update_equirect2_descriptor(struct comp_render_layer *self, 192 + struct xrt_layer_equirect2_data *data) 193 193 { 194 194 _update_descriptor_equirect(self, self->descriptor_equirect, 195 - self->equirect_ubo.handle); 195 + self->equirect2_ubo.handle); 196 196 197 - self->equirect_data = (struct layer_equirect_data){ 197 + self->equirect2_data = (struct layer_equirect2_data){ 198 198 .radius = data->radius, 199 199 .central_horizontal_angle = data->central_horizontal_angle, 200 200 .upper_vertical_angle = data->upper_vertical_angle, 201 201 .lower_vertical_angle = data->lower_vertical_angle, 202 202 }; 203 - memcpy(self->equirect_ubo.data, &self->equirect_data, 204 - sizeof(struct layer_equirect_data)); 203 + memcpy(self->equirect2_ubo.data, &self->equirect2_data, 204 + sizeof(struct layer_equirect2_data)); 205 205 } 206 206 207 207 void ··· 236 236 if (!_init_ubos(self)) 237 237 return false; 238 238 239 - if (!_init_equirect_ubo(self)) 239 + if (!_init_equirect2_ubo(self)) 240 240 return false; 241 241 242 242 VkDescriptorPoolSize pool_sizes[] = { ··· 301 301 break; 302 302 case XRT_LAYER_QUAD: 303 303 case XRT_LAYER_CYLINDER: 304 - case XRT_LAYER_EQUIRECT: _update_mvp_matrix(self, eye, vp); break; 304 + case XRT_LAYER_EQUIRECT2: _update_mvp_matrix(self, eye, vp); break; 305 305 case XRT_LAYER_STEREO_PROJECTION_DEPTH: 306 306 case XRT_LAYER_CUBE: 307 307 // Should never end up here. ··· 309 309 } 310 310 311 311 312 - if (self->type == XRT_LAYER_EQUIRECT) { 312 + if (self->type == XRT_LAYER_EQUIRECT2) { 313 313 const VkDescriptorSet sets[2] = { 314 314 self->descriptor_sets[eye], 315 315 self->descriptor_equirect, ··· 477 477 for (uint32_t eye = 0; eye < 2; eye++) 478 478 vk_buffer_destroy(&self->transformation_ubos[eye], self->vk); 479 479 480 - vk_buffer_destroy(&self->equirect_ubo, self->vk); 480 + vk_buffer_destroy(&self->equirect2_ubo, self->vk); 481 481 482 482 self->vk->vkDestroyDescriptorPool(self->vk->device, 483 483 self->descriptor_pool, NULL);
+5 -5
src/xrt/compositor/main/comp_layer.h
··· 20 20 bool flip_y; 21 21 }; 22 22 23 - struct layer_equirect_data 23 + struct layer_equirect2_data 24 24 { 25 25 float radius; 26 26 float central_horizontal_angle; ··· 41 41 struct layer_transformation transformation[2]; 42 42 struct vk_buffer transformation_ubos[2]; 43 43 44 - struct layer_equirect_data equirect_data; 45 - struct vk_buffer equirect_ubo; 44 + struct layer_equirect2_data equirect2_data; 45 + struct vk_buffer equirect2_ubo; 46 46 47 47 VkDescriptorPool descriptor_pool; 48 48 VkDescriptorSet descriptor_sets[2]; ··· 105 105 float central_angle); 106 106 107 107 void 108 - comp_layer_update_equirect_descriptor(struct comp_render_layer *self, 109 - struct xrt_layer_equirect_data *data); 108 + comp_layer_update_equirect2_descriptor(struct comp_render_layer *self, 109 + struct xrt_layer_equirect2_data *data);
+5 -5
src/xrt/compositor/main/comp_layer_renderer.c
··· 407 407 ? self->pipeline_premultiplied_alpha 408 408 : self->pipeline_unpremultiplied_alpha; 409 409 410 - if (self->layers[i]->type == XRT_LAYER_EQUIRECT) { 411 - pipeline = self->pipeline_equirect; 410 + if (self->layers[i]->type == XRT_LAYER_EQUIRECT2) { 411 + pipeline = self->pipeline_equirect2; 412 412 comp_layer_draw(self->layers[i], eye, pipeline, 413 413 pipeline_layout, cmd_buffer, 414 414 vertex_buffer, &vp_inv, &vp_inv); ··· 553 553 return false; 554 554 } 555 555 556 - if (!_init_graphics_pipeline(self, s->equirect_vert, s->equirect_frag, 557 - true, &self->pipeline_equirect)) { 556 + if (!_init_graphics_pipeline(self, s->equirect2_vert, s->equirect2_frag, 557 + true, &self->pipeline_equirect2)) { 558 558 return false; 559 559 } 560 560 ··· 696 696 NULL); 697 697 vk->vkDestroyPipeline(vk->device, self->pipeline_unpremultiplied_alpha, 698 698 NULL); 699 - vk->vkDestroyPipeline(vk->device, self->pipeline_equirect, NULL); 699 + vk->vkDestroyPipeline(vk->device, self->pipeline_equirect2, NULL); 700 700 701 701 for (uint32_t i = 0; i < ARRAY_SIZE(self->shader_modules); i++) 702 702 vk->vkDestroyShaderModule(vk->device, self->shader_modules[i],
+1 -1
src/xrt/compositor/main/comp_layer_renderer.h
··· 39 39 VkShaderModule shader_modules[2]; 40 40 VkPipeline pipeline_premultiplied_alpha; 41 41 VkPipeline pipeline_unpremultiplied_alpha; 42 - VkPipeline pipeline_equirect; 42 + VkPipeline pipeline_equirect2; 43 43 VkDescriptorSetLayout descriptor_set_layout; 44 44 VkDescriptorSetLayout descriptor_set_layout_equirect; 45 45
+12 -11
src/xrt/compositor/main/comp_renderer.c
··· 575 575 } 576 576 577 577 void 578 - comp_renderer_set_equirect_layer(struct comp_renderer *r, 579 - uint32_t layer, 580 - struct comp_swapchain_image *image, 581 - struct xrt_layer_data *data) 578 + comp_renderer_set_equirect2_layer(struct comp_renderer *r, 579 + uint32_t layer, 580 + struct comp_swapchain_image *image, 581 + struct xrt_layer_data *data) 582 582 { 583 583 584 584 struct xrt_vec3 s = {1.0f, 1.0f, 1.0f}; 585 585 struct xrt_matrix_4x4 model_matrix; 586 - math_matrix_4x4_model(&data->equirect.pose, &s, &model_matrix); 586 + math_matrix_4x4_model(&data->equirect2.pose, &s, &model_matrix); 587 587 588 588 comp_layer_set_flip_y(r->lr->layers[layer], data->flip_y); 589 589 590 590 struct comp_render_layer *l = r->lr->layers[layer]; 591 - l->type = XRT_LAYER_EQUIRECT; 592 - l->visibility = data->equirect.visibility; 591 + l->type = XRT_LAYER_EQUIRECT2; 592 + l->visibility = data->equirect2.visibility; 593 593 l->flags = data->flags; 594 594 l->view_space = 595 595 (data->flags & XRT_LAYER_COMPOSITION_VIEW_SPACE_BIT) != 0; ··· 598 598 599 599 comp_layer_update_descriptors( 600 600 l, image->repeat_sampler, 601 - get_image_view(image, data->flags, data->equirect.sub.array_index)); 601 + get_image_view(image, data->flags, 602 + data->equirect2.sub.array_index)); 602 603 603 - comp_layer_update_equirect_descriptor(l, &data->equirect); 604 + comp_layer_update_equirect2_descriptor(l, &data->equirect2); 604 605 605 606 for (uint32_t i = 0; i < 2; i++) { 606 - l->transformation[i].offset = data->equirect.sub.rect.offset; 607 - l->transformation[i].extent = data->equirect.sub.rect.extent; 607 + l->transformation[i].offset = data->equirect2.sub.rect.offset; 608 + l->transformation[i].extent = data->equirect2.sub.rect.extent; 608 609 } 609 610 } 610 611
+4 -4
src/xrt/compositor/main/comp_renderer.h
··· 74 74 struct xrt_layer_data *data); 75 75 76 76 void 77 - comp_renderer_set_equirect_layer(struct comp_renderer *r, 78 - uint32_t layer, 79 - struct comp_swapchain_image *image, 80 - struct xrt_layer_data *data); 77 + comp_renderer_set_equirect2_layer(struct comp_renderer *r, 78 + uint32_t layer, 79 + struct comp_swapchain_image *image, 80 + struct xrt_layer_data *data); 81 81 82 82 void 83 83 comp_renderer_allocate_layers(struct comp_renderer *self, uint32_t num_layers);
+12 -12
src/xrt/compositor/main/comp_shaders.c
··· 22 22 23 23 #include "shaders/layer.frag.h" 24 24 #include "shaders/layer.vert.h" 25 - #include "shaders/equirect.frag.h" 26 - #include "shaders/equirect.vert.h" 25 + #include "shaders/equirect2.frag.h" 26 + #include "shaders/equirect2.vert.h" 27 27 #include "shaders/mesh.frag.h" 28 28 #include "shaders/mesh.vert.h" 29 29 ··· 89 89 sizeof(shaders_mesh_frag), // size 90 90 &s->mesh_frag)); // out 91 91 92 - C(shader_load(vk, // vk_bundle 93 - shaders_equirect_vert, // data 94 - sizeof(shaders_equirect_vert), // size 95 - &s->equirect_vert)); // out 96 - C(shader_load(vk, // vk_bundle 97 - shaders_equirect_frag, // data 98 - sizeof(shaders_equirect_frag), // size 99 - &s->equirect_frag)); // out 92 + C(shader_load(vk, // vk_bundle 93 + shaders_equirect2_vert, // data 94 + sizeof(shaders_equirect2_vert), // size 95 + &s->equirect2_vert)); // out 96 + C(shader_load(vk, // vk_bundle 97 + shaders_equirect2_frag, // data 98 + sizeof(shaders_equirect2_frag), // size 99 + &s->equirect2_frag)); // out 100 100 101 101 C(shader_load(vk, // vk_bundle 102 102 shaders_layer_vert, // data ··· 123 123 { 124 124 D(mesh_vert); 125 125 D(mesh_frag); 126 - D(equirect_vert); 127 - D(equirect_frag); 126 + D(equirect2_vert); 127 + D(equirect2_frag); 128 128 D(layer_vert); 129 129 D(layer_frag); 130 130
src/xrt/compositor/shaders/equirect.frag src/xrt/compositor/shaders/equirect2.frag
src/xrt/compositor/shaders/equirect.vert src/xrt/compositor/shaders/equirect2.vert
+2 -2
src/xrt/compositor/shaders/meson.build
··· 6 6 'mesh.vert', 7 7 'layer.vert', 8 8 'layer.frag', 9 - 'equirect.vert', 10 - 'equirect.frag' 9 + 'equirect2.vert', 10 + 'equirect2.frag' 11 11 ] 12 12 13 13 shader_headers = []
+1 -1
src/xrt/include/xrt/meson.build
··· 98 98 endif 99 99 100 100 if get_option('layer_equirect2') 101 - have_conf.set('XRT_FEATURE_OPENXR_LAYER_EQUIRECT', true) 101 + have_conf.set('XRT_FEATURE_OPENXR_LAYER_EQUIRECT2', true) 102 102 endif 103 103 104 104 xrt_config_have_h = configure_file(
+15 -15
src/xrt/include/xrt/xrt_compositor.h
··· 96 96 XRT_LAYER_QUAD, 97 97 XRT_LAYER_CUBE, 98 98 XRT_LAYER_CYLINDER, 99 - XRT_LAYER_EQUIRECT, 99 + XRT_LAYER_EQUIRECT2, 100 100 }; 101 101 102 102 /*! ··· 250 250 }; 251 251 252 252 /*! 253 - * All the pure data values associated with a equirect layer. 253 + * All the pure data values associated with a equirect2 layer. 254 254 * 255 255 * The @ref xrt_swapchain references and @ref xrt_device are provided outside of 256 256 * this struct. 257 257 */ 258 - struct xrt_layer_equirect_data 258 + struct xrt_layer_equirect2_data 259 259 { 260 260 enum xrt_layer_eye_visibility visibility; 261 261 ··· 327 327 struct xrt_layer_quad_data quad; 328 328 struct xrt_layer_cube_data cube; 329 329 struct xrt_layer_cylinder_data cylinder; 330 - struct xrt_layer_equirect_data equirect; 330 + struct xrt_layer_equirect2_data equirect2; 331 331 }; 332 332 }; 333 333 ··· 723 723 const struct xrt_layer_data *data); 724 724 725 725 /*! 726 - * Adds a equirect layer for submission. 726 + * Adds a equirect2 layer for submission. 727 727 * 728 728 * @param xc Self pointer 729 729 * @param xdev The device the layer is relative to. 730 730 * @param xsc Swapchain. 731 731 * @param data All of the pure data bits. 732 732 */ 733 - xrt_result_t (*layer_equirect)(struct xrt_compositor *xc, 734 - struct xrt_device *xdev, 735 - struct xrt_swapchain *xsc, 736 - const struct xrt_layer_data *data); 733 + xrt_result_t (*layer_equirect2)(struct xrt_compositor *xc, 734 + struct xrt_device *xdev, 735 + struct xrt_swapchain *xsc, 736 + const struct xrt_layer_data *data); 737 737 738 738 /*! 739 739 * Commits all of the submitted layers, it's from this on that the ··· 982 982 } 983 983 984 984 /*! 985 - * @copydoc xrt_compositor::layer_equirect 985 + * @copydoc xrt_compositor::layer_equirect2 986 986 * 987 987 * Helper for calling through the function pointer. 988 988 * 989 989 * @public @memberof xrt_compositor 990 990 */ 991 991 static inline xrt_result_t 992 - xrt_comp_layer_equirect(struct xrt_compositor *xc, 993 - struct xrt_device *xdev, 994 - struct xrt_swapchain *xsc, 995 - const struct xrt_layer_data *data) 992 + xrt_comp_layer_equirect2(struct xrt_compositor *xc, 993 + struct xrt_device *xdev, 994 + struct xrt_swapchain *xsc, 995 + const struct xrt_layer_data *data) 996 996 { 997 - return xc->layer_equirect(xc, xdev, xsc, data); 997 + return xc->layer_equirect2(xc, xdev, xsc, data); 998 998 } 999 999 1000 1000 /*!
+1 -1
src/xrt/include/xrt/xrt_config_build.h.cmake_in
··· 21 21 22 22 #cmakedefine XRT_FEATURE_OPENXR_LAYER_DEPTH 23 23 24 - #cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT 24 + #cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT2 25 25 26 26 #cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY
+6 -6
src/xrt/ipc/client/ipc_client_compositor.c
··· 592 592 } 593 593 594 594 static xrt_result_t 595 - ipc_compositor_layer_equirect(struct xrt_compositor *xc, 596 - struct xrt_device *xdev, 597 - struct xrt_swapchain *xsc, 598 - const struct xrt_layer_data *data) 595 + ipc_compositor_layer_equirect2(struct xrt_compositor *xc, 596 + struct xrt_device *xdev, 597 + struct xrt_swapchain *xsc, 598 + const struct xrt_layer_data *data) 599 599 { 600 - return handle_layer(xc, xdev, xsc, data, XRT_LAYER_EQUIRECT); 600 + return handle_layer(xc, xdev, xsc, data, XRT_LAYER_EQUIRECT2); 601 601 } 602 602 603 603 static xrt_result_t ··· 785 785 c->base.base.layer_quad = ipc_compositor_layer_quad; 786 786 c->base.base.layer_cube = ipc_compositor_layer_cube; 787 787 c->base.base.layer_cylinder = ipc_compositor_layer_cylinder; 788 - c->base.base.layer_equirect = ipc_compositor_layer_equirect; 788 + c->base.base.layer_equirect2 = ipc_compositor_layer_equirect2; 789 789 c->base.base.layer_commit = ipc_compositor_layer_commit; 790 790 c->base.base.destroy = ipc_compositor_destroy; 791 791 c->base.base.poll_events = ipc_compositor_poll_events;
+1 -1
src/xrt/ipc/server/ipc_server_per_client_thread.c
··· 164 164 rl->data.quad.sub.image_index = 0; 165 165 rl->data.cube.sub.image_index = 0; 166 166 rl->data.cylinder.sub.image_index = 0; 167 - rl->data.equirect.sub.image_index = 0; 167 + rl->data.equirect2.sub.image_index = 0; 168 168 169 169 //! @todo set rects or array index? 170 170 }
+9 -9
src/xrt/ipc/server/ipc_server_process.c
··· 869 869 } 870 870 871 871 static bool 872 - _update_equirect_layer(struct xrt_compositor *xc, 873 - volatile struct ipc_client_state *ics, 874 - volatile struct ipc_layer_entry *layer, 875 - uint32_t i) 872 + _update_equirect2_layer(struct xrt_compositor *xc, 873 + volatile struct ipc_client_state *ics, 874 + volatile struct ipc_layer_entry *layer, 875 + uint32_t i) 876 876 { 877 877 struct xrt_device *xdev; 878 878 struct xrt_swapchain *xcs; 879 879 struct xrt_layer_data *data; 880 880 881 - if (!do_single(xc, ics, layer, i, "equirect", &xdev, &xcs, &data)) { 881 + if (!do_single(xc, ics, layer, i, "equirect2", &xdev, &xcs, &data)) { 882 882 return false; 883 883 } 884 884 885 - xrt_comp_layer_equirect(xc, xdev, xcs, data); 885 + xrt_comp_layer_equirect2(xc, xdev, xcs, data); 886 886 887 887 return true; 888 888 } ··· 974 974 return false; 975 975 } 976 976 break; 977 - case XRT_LAYER_EQUIRECT: 978 - if (!_update_equirect_layer(xc, ics, layer, 979 - i)) { 977 + case XRT_LAYER_EQUIRECT2: 978 + if (!_update_equirect2_layer(xc, ics, layer, 979 + i)) { 980 980 return false; 981 981 } 982 982 break;
+1 -1
src/xrt/state_trackers/oxr/oxr_extension_support.h
··· 136 136 * XR_KHR_composition_layer_equirect2 137 137 */ 138 138 #if defined(XR_KHR_composition_layer_equirect2) && \ 139 - defined(XRT_FEATURE_OPENXR_LAYER_EQUIRECT) 139 + defined(XRT_FEATURE_OPENXR_LAYER_EQUIRECT2) 140 140 #define OXR_HAVE_KHR_composition_layer_equirect2 141 141 #define OXR_EXTENSION_SUPPORT_KHR_composition_layer_equirect2(_) \ 142 142 _(KHR_composition_layer_equirect2, KHR_COMPOSITION_LAYER_EQUIRECT2)
+2 -2
src/xrt/state_trackers/oxr/oxr_instance.c
··· 353 353 CHECK_LAYER_TYPE("projection layers with depth images", 354 354 layer_stereo_projection_depth); 355 355 #endif 356 - #ifdef XRT_FEATURE_OPENXR_LAYER_EQUIRECT 357 - CHECK_LAYER_TYPE("equirect layers", layer_equirect); 356 + #ifdef XRT_FEATURE_OPENXR_LAYER_EQUIRECT2 357 + CHECK_LAYER_TYPE("equirect2 layers", layer_equirect2); 358 358 #endif 359 359 #undef CHECK_LAYER_TYPE 360 360 }
+13 -13
src/xrt/state_trackers/oxr/oxr_session.c
··· 1224 1224 struct xrt_device *head, 1225 1225 uint64_t timestamp) 1226 1226 { 1227 - #ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT 1227 + #ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT2 1228 1228 return oxr_error(log, XR_ERROR_LAYER_INVALID, 1229 1229 "(frameEndInfo->layers[%u]->type) layer type " 1230 1230 "XrCompositionLayerEquirectKHR not supported", ··· 1329 1329 struct xrt_device *head, 1330 1330 uint64_t timestamp) 1331 1331 { 1332 - #ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT 1332 + #ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT2 1333 1333 return oxr_error(log, XR_ERROR_LAYER_INVALID, 1334 1334 "(frameEndInfo->layers[%u]->type) layer type " 1335 1335 "XrCompositionLayerEquirect2KHR not supported", ··· 1851 1851 1852 1852 struct xrt_layer_data data; 1853 1853 U_ZERO(&data); 1854 - data.type = XRT_LAYER_EQUIRECT; 1854 + data.type = XRT_LAYER_EQUIRECT2; 1855 1855 data.name = XRT_INPUT_GENERIC_HEAD_POSE; 1856 1856 data.timestamp = timestamp; 1857 1857 data.flags = flags; ··· 1859 1859 struct xrt_rect *rect = 1860 1860 (struct xrt_rect *)&equirect->subImage.imageRect; 1861 1861 1862 - data.equirect.visibility = 1862 + data.equirect2.visibility = 1863 1863 convert_eye_visibility(equirect->eyeVisibility); 1864 - data.equirect.sub.image_index = sc->released.index; 1865 - data.equirect.sub.array_index = equirect->subImage.imageArrayIndex; 1866 - data.equirect.sub.rect = *rect; 1867 - data.equirect.pose = pose; 1864 + data.equirect2.sub.image_index = sc->released.index; 1865 + data.equirect2.sub.array_index = equirect->subImage.imageArrayIndex; 1866 + data.equirect2.sub.rect = *rect; 1867 + data.equirect2.pose = pose; 1868 1868 1869 - data.equirect.radius = equirect->radius; 1870 - data.equirect.central_horizontal_angle = 1869 + data.equirect2.radius = equirect->radius; 1870 + data.equirect2.central_horizontal_angle = 1871 1871 equirect->centralHorizontalAngle; 1872 - data.equirect.upper_vertical_angle = equirect->upperVerticalAngle; 1873 - data.equirect.lower_vertical_angle = equirect->lowerVerticalAngle; 1872 + data.equirect2.upper_vertical_angle = equirect->upperVerticalAngle; 1873 + data.equirect2.lower_vertical_angle = equirect->lowerVerticalAngle; 1874 1874 1875 - CALL_CHK(xrt_comp_layer_equirect(xc, head, sc->swapchain, &data)); 1875 + CALL_CHK(xrt_comp_layer_equirect2(xc, head, sc->swapchain, &data)); 1876 1876 1877 1877 return XR_SUCCESS; 1878 1878 }