+15 -16

src/xrt/compositor/client/comp_d3d11_client.cpp

··· 564 564 assert(data->type == XRT_LAYER_PROJECTION); 565 565 566 566 struct xrt_swapchain *xscn[XRT_MAX_VIEWS]; 567 567 - for (uint32_t i = 0; i < data->proj.view_count; ++i) { 567 567 + for (uint32_t i = 0; i < data->view_count; ++i) { 568 568 xscn[i] = as_client_d3d11_swapchain(xsc[i])->xsc.get(); 569 569 } 570 570 ··· 573 573 } 574 574 575 575 static xrt_result_t 576 576 - client_d3d11_compositor_layer_stereo_projection_depth(struct xrt_compositor *xc, 577 577 - struct xrt_device *xdev, 578 578 - struct xrt_swapchain *l_xsc, 579 579 - struct xrt_swapchain *r_xsc, 580 580 - struct xrt_swapchain *l_d_xsc, 581 581 - struct xrt_swapchain *r_d_xsc, 582 582 - const struct xrt_layer_data *data) 576 576 + client_d3d11_compositor_layer_projection_depth(struct xrt_compositor *xc, 577 577 + struct xrt_device *xdev, 578 578 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 579 579 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 580 580 + const struct xrt_layer_data *data) 583 581 { 584 582 struct client_d3d11_compositor *c = as_client_d3d11_compositor(xc); 585 583 586 586 - assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH); 587 587 - 588 588 - struct xrt_swapchain *l_xscn = as_client_d3d11_swapchain(l_xsc)->xsc.get(); 589 589 - struct xrt_swapchain *r_xscn = as_client_d3d11_swapchain(r_xsc)->xsc.get(); 590 590 - struct xrt_swapchain *l_d_xscn = as_client_d3d11_swapchain(l_d_xsc)->xsc.get(); 591 591 - struct xrt_swapchain *r_d_xscn = as_client_d3d11_swapchain(r_d_xsc)->xsc.get(); 584 584 + assert(data->type == XRT_LAYER_PROJECTION_DEPTH); 585 585 + struct xrt_swapchain *xscn[XRT_MAX_VIEWS]; 586 586 + struct xrt_swapchain *d_xscn[XRT_MAX_VIEWS]; 587 587 + for (uint32_t i = 0; i < data->view_count; ++i) { 588 588 + xscn[i] = as_client_d3d11_swapchain(xsc[i])->xsc.get(); 589 589 + d_xscn[i] = as_client_d3d11_swapchain(d_xsc[i])->xsc.get(); 590 590 + } 592 591 593 592 // No flip required: D3D11 swapchain image convention matches Vulkan. 594 594 - return xrt_comp_layer_stereo_projection_depth(&c->xcn->base, xdev, l_xscn, r_xscn, l_d_xscn, r_d_xscn, data); 593 593 + return xrt_comp_layer_projection_depth(&c->xcn->base, xdev, xscn, d_xscn, data); 595 594 } 596 595 597 596 static xrt_result_t ··· 881 880 c->base.base.discard_frame = client_d3d11_compositor_discard_frame; 882 881 c->base.base.layer_begin = client_d3d11_compositor_layer_begin; 883 882 c->base.base.layer_projection = client_d3d11_compositor_layer_projection; 884 884 - c->base.base.layer_stereo_projection_depth = client_d3d11_compositor_layer_stereo_projection_depth; 883 883 + c->base.base.layer_projection_depth = client_d3d11_compositor_layer_projection_depth; 885 884 c->base.base.layer_quad = client_d3d11_compositor_layer_quad; 886 885 c->base.base.layer_cube = client_d3d11_compositor_layer_cube; 887 886 c->base.base.layer_cylinder = client_d3d11_compositor_layer_cylinder;

+19 -20

src/xrt/compositor/client/comp_d3d12_client.cpp

··· 792 792 assert(data->type == XRT_LAYER_PROJECTION); 793 793 794 794 struct xrt_swapchain *xscn[XRT_MAX_VIEWS]; 795 795 - for (uint32_t i = 0; i < data->proj.view_count; ++i) { 795 795 + for (uint32_t i = 0; i < data->view_count; ++i) { 796 796 xscn[i] = as_client_d3d12_swapchain(xsc[i])->xsc.get(); 797 797 } 798 798 struct xrt_layer_data d = *data; ··· 802 802 } 803 803 804 804 static xrt_result_t 805 805 - client_d3d12_compositor_layer_stereo_projection_depth(struct xrt_compositor *xc, 806 806 - struct xrt_device *xdev, 807 807 - struct xrt_swapchain *l_xsc, 808 808 - struct xrt_swapchain *r_xsc, 809 809 - struct xrt_swapchain *l_d_xsc, 810 810 - struct xrt_swapchain *r_d_xsc, 811 811 - const struct xrt_layer_data *data) 805 805 + client_d3d12_compositor_layer_projection_depth(struct xrt_compositor *xc, 806 806 + struct xrt_device *xdev, 807 807 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 808 808 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 809 809 + const struct xrt_layer_data *data) 812 810 { 813 811 struct client_d3d12_compositor *c = as_client_d3d12_compositor(xc); 814 812 815 815 - assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH); 813 813 + assert(data->type == XRT_LAYER_PROJECTION_DEPTH); 816 814 817 817 - struct xrt_swapchain *l_xscn = as_client_d3d12_swapchain(l_xsc)->xsc.get(); 818 818 - struct xrt_swapchain *r_xscn = as_client_d3d12_swapchain(r_xsc)->xsc.get(); 819 819 - struct xrt_swapchain *l_d_xscn = as_client_d3d12_swapchain(l_d_xsc)->xsc.get(); 820 820 - struct xrt_swapchain *r_d_xscn = as_client_d3d12_swapchain(r_d_xsc)->xsc.get(); 815 815 + struct xrt_swapchain *xscn[XRT_MAX_VIEWS]; 816 816 + struct xrt_swapchain *d_xscn[XRT_MAX_VIEWS]; 817 817 + for (uint32_t i = 0; i < data->view_count; ++i) { 818 818 + xscn[i] = as_client_d3d12_swapchain(xsc[i])->xsc.get(); 819 819 + d_xscn[i] = as_client_d3d12_swapchain(d_xsc[i])->xsc.get(); 820 820 + } 821 821 822 822 struct xrt_layer_data d = *data; 823 823 - client_d3d12_swapchain_scale_rect(l_xsc, &d.stereo_depth.l.sub.norm_rect); 824 824 - client_d3d12_swapchain_scale_rect(r_xsc, &d.stereo_depth.r.sub.norm_rect); 825 825 - client_d3d12_swapchain_scale_rect(l_d_xsc, &d.stereo_depth.l_d.sub.norm_rect); 826 826 - client_d3d12_swapchain_scale_rect(r_d_xsc, &d.stereo_depth.r_d.sub.norm_rect); 827 827 - 823 823 + for (uint32_t i = 0; i < data->view_count; ++i) { 824 824 + client_d3d12_swapchain_scale_rect(xsc[i], &d.depth.v[i].sub.norm_rect); 825 825 + client_d3d12_swapchain_scale_rect(d_xsc[i], &d.depth.d[i].sub.norm_rect); 826 826 + } 828 827 // No flip required: D3D12 swapchain image convention matches Vulkan. 829 829 - return xrt_comp_layer_stereo_projection_depth(&c->xcn->base, xdev, l_xscn, r_xscn, l_d_xscn, r_d_xscn, &d); 828 828 + return xrt_comp_layer_projection_depth(&c->xcn->base, xdev, xscn, d_xscn, &d); 830 829 } 831 830 832 831 static xrt_result_t ··· 1136 1135 c->base.base.discard_frame = client_d3d12_compositor_discard_frame; 1137 1136 c->base.base.layer_begin = client_d3d12_compositor_layer_begin; 1138 1137 c->base.base.layer_projection = client_d3d12_compositor_layer_projection; 1139 1139 - c->base.base.layer_stereo_projection_depth = client_d3d12_compositor_layer_stereo_projection_depth; 1138 1138 + c->base.base.layer_projection_depth = client_d3d12_compositor_layer_projection_depth; 1140 1139 c->base.base.layer_quad = client_d3d12_compositor_layer_quad; 1141 1140 c->base.base.layer_cube = client_d3d12_compositor_layer_cube; 1142 1141 c->base.base.layer_cylinder = client_d3d12_compositor_layer_cylinder;

+15 -19

src/xrt/compositor/client/comp_gl_client.c

··· 239 239 240 240 xcn = to_native_compositor(xc); 241 241 assert(data->type == XRT_LAYER_PROJECTION); 242 242 - for (uint32_t i = 0; i < data->proj.view_count; ++i) { 242 242 + for (uint32_t i = 0; i < data->view_count; ++i) { 243 243 xscn[i] = &client_gl_swapchain(xsc[i])->xscn->base; 244 244 } 245 245 struct xrt_layer_data d = *data; ··· 249 249 } 250 250 251 251 static xrt_result_t 252 252 - client_gl_compositor_layer_stereo_projection_depth(struct xrt_compositor *xc, 253 253 - struct xrt_device *xdev, 254 254 - struct xrt_swapchain *l_xsc, 255 255 - struct xrt_swapchain *r_xsc, 256 256 - struct xrt_swapchain *l_d_xsc, 257 257 - struct xrt_swapchain *r_d_xsc, 258 258 - const struct xrt_layer_data *data) 252 252 + client_gl_compositor_layer_projection_depth(struct xrt_compositor *xc, 253 253 + struct xrt_device *xdev, 254 254 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 255 255 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 256 256 + const struct xrt_layer_data *data) 259 257 { 260 258 struct xrt_compositor *xcn; 261 261 - struct xrt_swapchain *l_xscn; 262 262 - struct xrt_swapchain *r_xscn; 263 263 - struct xrt_swapchain *l_d_xscn; 264 264 - struct xrt_swapchain *r_d_xscn; 259 259 + struct xrt_swapchain *xscn[XRT_MAX_VIEWS]; 260 260 + struct xrt_swapchain *d_xscn[XRT_MAX_VIEWS]; 265 261 266 266 - assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH); 262 262 + assert(data->type == XRT_LAYER_PROJECTION_DEPTH); 267 263 268 264 xcn = to_native_compositor(xc); 269 269 - l_xscn = to_native_swapchain(l_xsc); 270 270 - r_xscn = to_native_swapchain(r_xsc); 271 271 - l_d_xscn = to_native_swapchain(l_d_xsc); 272 272 - r_d_xscn = to_native_swapchain(r_d_xsc); 265 265 + for (uint32_t i = 0; i < data->view_count; ++i) { 266 266 + xscn[i] = to_native_swapchain(xsc[i]); 267 267 + d_xscn[i] = to_native_swapchain(d_xsc[i]); 268 268 + } 273 269 274 270 struct xrt_layer_data d = *data; 275 271 d.flip_y = !d.flip_y; 276 272 277 277 - return xrt_comp_layer_stereo_projection_depth(xcn, xdev, l_xscn, r_xscn, l_d_xscn, r_d_xscn, &d); 273 273 + return xrt_comp_layer_projection_depth(xcn, xdev, xscn, d_xscn, &d); 278 274 } 279 275 280 276 static xrt_result_t ··· 611 607 c->base.base.discard_frame = client_gl_compositor_discard_frame; 612 608 c->base.base.layer_begin = client_gl_compositor_layer_begin; 613 609 c->base.base.layer_projection = client_gl_compositor_layer_projection; 614 614 - c->base.base.layer_stereo_projection_depth = client_gl_compositor_layer_stereo_projection_depth; 610 610 + c->base.base.layer_projection_depth = client_gl_compositor_layer_projection_depth; 615 611 c->base.base.layer_quad = client_gl_compositor_layer_quad; 616 612 c->base.base.layer_cube = client_gl_compositor_layer_cube; 617 613 c->base.base.layer_cylinder = client_gl_compositor_layer_cylinder;

+13 -16

src/xrt/compositor/client/comp_vk_client.c

··· 483 483 struct xrt_swapchain *xscn[XRT_MAX_VIEWS]; 484 484 485 485 assert(data->type == XRT_LAYER_PROJECTION); 486 486 - for (uint32_t i = 0; i < data->proj.view_count; ++i) { 486 486 + for (uint32_t i = 0; i < data->view_count; ++i) { 487 487 xscn[i] = &client_vk_swapchain(xsc[i])->xscn->base; 488 488 } 489 489 ··· 496 496 static xrt_result_t 497 497 client_vk_compositor_layer_stereo_projection_depth(struct xrt_compositor *xc, 498 498 struct xrt_device *xdev, 499 499 - struct xrt_swapchain *l_xsc, 500 500 - struct xrt_swapchain *r_xsc, 501 501 - struct xrt_swapchain *l_d_xsc, 502 502 - struct xrt_swapchain *r_d_xsc, 499 499 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 500 500 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 503 501 const struct xrt_layer_data *data) 504 502 { 505 503 struct xrt_compositor *xcn; 506 506 - struct xrt_swapchain *l_xscn; 507 507 - struct xrt_swapchain *r_xscn; 508 508 - struct xrt_swapchain *l_d_xscn; 509 509 - struct xrt_swapchain *r_d_xscn; 504 504 + 505 505 + struct xrt_swapchain *xscn[XRT_MAX_VIEWS]; 506 506 + struct xrt_swapchain *d_xscn[XRT_MAX_VIEWS]; 510 507 511 511 - assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH); 508 508 + assert(data->type == XRT_LAYER_PROJECTION_DEPTH); 512 509 513 510 xcn = to_native_compositor(xc); 514 514 - l_xscn = to_native_swapchain(l_xsc); 515 515 - r_xscn = to_native_swapchain(r_xsc); 516 516 - l_d_xscn = to_native_swapchain(l_d_xsc); 517 517 - r_d_xscn = to_native_swapchain(r_d_xsc); 511 511 + for (uint32_t i = 0; i < data->view_count; ++i) { 512 512 + xscn[i] = to_native_swapchain(xsc[i]); 513 513 + d_xscn[i] = to_native_swapchain(d_xsc[i]); 514 514 + } 518 515 519 519 - return xrt_comp_layer_stereo_projection_depth(xcn, xdev, l_xscn, r_xscn, l_d_xscn, r_d_xscn, data); 516 516 + return xrt_comp_layer_projection_depth(xcn, xdev, xscn, d_xscn, data); 520 517 } 521 518 522 519 static xrt_result_t ··· 842 839 c->base.base.discard_frame = client_vk_compositor_discard_frame; 843 840 c->base.base.layer_begin = client_vk_compositor_layer_begin; 844 841 c->base.base.layer_projection = client_vk_compositor_layer_projection; 845 845 - c->base.base.layer_stereo_projection_depth = client_vk_compositor_layer_stereo_projection_depth; 842 842 + c->base.base.layer_projection_depth = client_vk_compositor_layer_stereo_projection_depth; 846 843 c->base.base.layer_quad = client_vk_compositor_layer_quad; 847 844 c->base.base.layer_cube = client_vk_compositor_layer_cube; 848 845 c->base.base.layer_cylinder = client_vk_compositor_layer_cylinder;

+1 -1

src/xrt/compositor/main/comp_compositor.c

··· 273 273 274 274 // Handled by the distortion shader. 275 275 if (type != XRT_LAYER_PROJECTION && // 276 276 - type != XRT_LAYER_STEREO_PROJECTION_DEPTH) { 276 276 + type != XRT_LAYER_PROJECTION_DEPTH) { 277 277 return false; 278 278 } 279 279

+1 -1

src/xrt/compositor/mock/mock_compositor.cpp

··· 189 189 // mc->base.base.discard_frame = mock_compositor_discard_frame; 190 190 // mc->base.base.layer_begin = mock_compositor_layer_begin; 191 191 // mc->base.base.layer_projection = mock_compositor_layer_projection; 192 192 - // mc->base.base.layer_stereo_projection_depth = mock_compositor_layer_stereo_projection_depth; 192 192 + // mc->base.base.layer_projection_depth = mock_compositor_layer_projection_depth; 193 193 // mc->base.base.layer_quad = mock_compositor_layer_quad; 194 194 // mc->base.base.layer_cube = mock_compositor_layer_cube; 195 195 // mc->base.base.layer_cylinder = mock_compositor_layer_cylinder;

+8 -8

src/xrt/compositor/mock/mock_compositor.h

··· 164 164 165 165 /*! 166 166 * Optional function pointer for mock compositor, called during @ref 167 167 - * xrt_comp_layer_stereo_projection_depth 167 167 + * xrt_comp_layer_projection_depth 168 168 */ 169 169 - xrt_result_t (*layer_stereo_projection_depth)(struct mock_compositor *mc, 170 170 - struct xrt_device *xdev, 171 171 - struct xrt_swapchain *l_xsc, 172 172 - struct xrt_swapchain *r_xsc, 173 173 - struct xrt_swapchain *l_d_xsc, 174 174 - struct xrt_swapchain *r_d_xsc, 175 175 - const struct xrt_layer_data *data); 169 169 + xrt_result_t (*layer_projection_depth)(struct mock_compositor *mc, 170 170 + struct xrt_device *xdev, 171 171 + struct xrt_swapchain *l_xsc, 172 172 + struct xrt_swapchain *r_xsc, 173 173 + struct xrt_swapchain *l_d_xsc, 174 174 + struct xrt_swapchain *r_d_xsc, 175 175 + const struct xrt_layer_data *data); 176 176 177 177 /*! 178 178 * Optional function pointer for mock compositor, called during @ref xrt_comp_layer_quad

+12 -13

src/xrt/compositor/multi/comp_multi_compositor.c

··· 655 655 656 656 size_t index = mc->progress.layer_count++; 657 657 mc->progress.layers[index].xdev = xdev; 658 658 - for (uint32_t i = 0; i < data->proj.view_count; ++i) { 658 658 + for (uint32_t i = 0; i < data->view_count; ++i) { 659 659 xrt_swapchain_reference(&mc->progress.layers[index].xscs[i], xsc[i]); 660 660 } 661 661 mc->progress.layers[index].data = *data; ··· 664 664 } 665 665 666 666 static xrt_result_t 667 667 - multi_compositor_layer_stereo_projection_depth(struct xrt_compositor *xc, 668 668 - struct xrt_device *xdev, 669 669 - struct xrt_swapchain *l_xsc, 670 670 - struct xrt_swapchain *r_xsc, 671 671 - struct xrt_swapchain *l_d_xsc, 672 672 - struct xrt_swapchain *r_d_xsc, 673 673 - const struct xrt_layer_data *data) 667 667 + multi_compositor_layer_projection_depth(struct xrt_compositor *xc, 668 668 + struct xrt_device *xdev, 669 669 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 670 670 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 671 671 + const struct xrt_layer_data *data) 674 672 { 675 673 struct multi_compositor *mc = multi_compositor(xc); 676 674 677 675 size_t index = mc->progress.layer_count++; 678 676 mc->progress.layers[index].xdev = xdev; 679 679 - xrt_swapchain_reference(&mc->progress.layers[index].xscs[0], l_xsc); 680 680 - xrt_swapchain_reference(&mc->progress.layers[index].xscs[1], r_xsc); 681 681 - xrt_swapchain_reference(&mc->progress.layers[index].xscs[2], l_d_xsc); 682 682 - xrt_swapchain_reference(&mc->progress.layers[index].xscs[3], r_d_xsc); 677 677 + 678 678 + for (uint32_t i = 0; i < data->view_count; ++i) { 679 679 + xrt_swapchain_reference(&mc->progress.layers[index].xscs[i], xsc[i]); 680 680 + xrt_swapchain_reference(&mc->progress.layers[index].xscs[i + data->view_count], d_xsc[i]); 681 681 + } 683 682 mc->progress.layers[index].data = *data; 684 683 685 684 return XRT_SUCCESS; ··· 970 969 mc->base.base.discard_frame = multi_compositor_discard_frame; 971 970 mc->base.base.layer_begin = multi_compositor_layer_begin; 972 971 mc->base.base.layer_projection = multi_compositor_layer_projection; 973 973 - mc->base.base.layer_stereo_projection_depth = multi_compositor_layer_stereo_projection_depth; 972 972 + mc->base.base.layer_projection_depth = multi_compositor_layer_projection_depth; 974 973 mc->base.base.layer_quad = multi_compositor_layer_quad; 975 974 mc->base.base.layer_cube = multi_compositor_layer_cube; 976 975 mc->base.base.layer_cylinder = multi_compositor_layer_cylinder;

+16 -12

src/xrt/compositor/multi/comp_multi_system.c

··· 57 57 struct xrt_layer_data *data = (struct xrt_layer_data *)&layer->data; 58 58 59 59 // Do not need to copy the reference, but should verify the pointers for consistency 60 60 - for (uint32_t j = 0; j < data->proj.view_count; j++) { 60 60 + for (uint32_t j = 0; j < data->view_count; j++) { 61 61 if (layer->xscs[j] == NULL) { 62 62 U_LOG_E("Invalid swap chain for projection layer #%u!", i); 63 63 return; ··· 79 79 uint32_t i) 80 80 { 81 81 struct xrt_device *xdev = layer->xdev; 82 82 - struct xrt_swapchain *l_xcs = layer->xscs[0]; 83 83 - struct xrt_swapchain *r_xcs = layer->xscs[1]; 84 84 - struct xrt_swapchain *l_d_xcs = layer->xscs[2]; 85 85 - struct xrt_swapchain *r_d_xcs = layer->xscs[3]; 86 82 87 87 - if (l_xcs == NULL || r_xcs == NULL || l_d_xcs == NULL || r_d_xcs == NULL) { 88 88 - U_LOG_E("Invalid swap chain for projection layer #%u!", i); 89 89 - return; 83 83 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS]; 84 84 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS]; 85 85 + // Cast away 86 86 + struct xrt_layer_data *data = (struct xrt_layer_data *)&layer->data; 87 87 + 88 88 + for (uint32_t j = 0; j < data->view_count; j++) { 89 89 + xsc[j] = layer->xscs[j]; 90 90 + d_xsc[j] = layer->xscs[j + data->view_count]; 91 91 + 92 92 + if (xsc[j] == NULL || d_xsc[j] == NULL) { 93 93 + U_LOG_E("Invalid swap chain for projection layer #%u!", i); 94 94 + return; 95 95 + } 90 96 } 91 97 92 98 if (xdev == NULL) { ··· 94 100 return; 95 101 } 96 102 97 97 - // Cast away 98 98 - struct xrt_layer_data *data = (struct xrt_layer_data *)&layer->data; 99 103 100 100 - xrt_comp_layer_stereo_projection_depth(xc, xdev, l_xcs, r_xcs, l_d_xcs, r_d_xcs, data); 104 104 + xrt_comp_layer_projection_depth(xc, xdev, xsc, d_xsc, data); 101 105 } 102 106 103 107 static bool ··· 284 288 285 289 switch (layer->data.type) { 286 290 case XRT_LAYER_PROJECTION: do_projection_layer(xc, mc, layer, i); break; 287 287 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: do_projection_layer_depth(xc, mc, layer, i); break; 291 291 + case XRT_LAYER_PROJECTION_DEPTH: do_projection_layer_depth(xc, mc, layer, i); break; 288 292 case XRT_LAYER_QUAD: do_quad_layer(xc, mc, layer, i); break; 289 293 case XRT_LAYER_CUBE: do_cube_layer(xc, mc, layer, i); break; 290 294 case XRT_LAYER_CYLINDER: do_cylinder_layer(xc, mc, layer, i); break;

+2 -2

src/xrt/compositor/shaders/layer.comp

··· 10 10 11 11 //! @todo should this be a spcialization const? 12 12 #define XRT_LAYER_PROJECTION 0 13 13 - #define XRT_LAYER_STEREO_PROJECTION_DEPTH 1 13 13 + #define XRT_LAYER_PROJECTION_DEPTH 1 14 14 #define XRT_LAYER_QUAD 2 15 15 #define XRT_LAYER_CUBE 3 16 16 #define XRT_LAYER_CYLINDER 4 ··· 465 465 rgba = do_equirect2(view_uv, layer); 466 466 break; 467 467 case XRT_LAYER_PROJECTION: 468 468 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: 468 468 + case XRT_LAYER_PROJECTION_DEPTH: 469 469 rgba = do_projection(view_uv, layer); 470 470 break; 471 471 case XRT_LAYER_QUAD:

+12 -14

src/xrt/compositor/util/comp_base.c

··· 125 125 uint32_t layer_id = cb->slot.layer_count; 126 126 127 127 struct comp_layer *layer = &cb->slot.layers[layer_id]; 128 128 - assert(ARRAY_SIZE(layer->sc_array) >= data->proj.view_count); 129 129 - for (uint32_t i = 0; i < data->proj.view_count; ++i) { 128 128 + assert(ARRAY_SIZE(layer->sc_array) >= data->view_count); 129 129 + for (uint32_t i = 0; i < data->view_count; ++i) { 130 130 layer->sc_array[i] = comp_swapchain(xsc[i]); 131 131 } 132 132 layer->data = *data; ··· 137 137 } 138 138 139 139 static xrt_result_t 140 140 - base_layer_stereo_projection_depth(struct xrt_compositor *xc, 141 141 - struct xrt_device *xdev, 142 142 - struct xrt_swapchain *l_xsc, 143 143 - struct xrt_swapchain *r_xsc, 144 144 - struct xrt_swapchain *l_d_xsc, 145 145 - struct xrt_swapchain *r_d_xsc, 146 146 - const struct xrt_layer_data *data) 140 140 + base_layer_projection_depth(struct xrt_compositor *xc, 141 141 + struct xrt_device *xdev, 142 142 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 143 143 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 144 144 + const struct xrt_layer_data *data) 147 145 { 148 146 struct comp_base *cb = comp_base(xc); 149 147 150 148 uint32_t layer_id = cb->slot.layer_count; 151 149 152 150 struct comp_layer *layer = &cb->slot.layers[layer_id]; 153 153 - layer->sc_array[0] = comp_swapchain(l_xsc); 154 154 - layer->sc_array[1] = comp_swapchain(r_xsc); 155 155 - layer->sc_array[2] = comp_swapchain(l_d_xsc); 156 156 - layer->sc_array[3] = comp_swapchain(r_d_xsc); 151 151 + for (uint32_t i = 0; i < data->view_count; ++i) { 152 152 + layer->sc_array[i] = comp_swapchain(xsc[i]); 153 153 + layer->sc_array[i + data->view_count] = comp_swapchain(d_xsc[i]); 154 154 + } 157 155 layer->data = *data; 158 156 159 157 cb->slot.layer_count++; ··· 258 256 cb->base.base.import_fence = base_import_fence; 259 257 cb->base.base.layer_begin = base_layer_begin; 260 258 cb->base.base.layer_projection = base_layer_projection; 261 261 - cb->base.base.layer_stereo_projection_depth = base_layer_stereo_projection_depth; 259 259 + cb->base.base.layer_projection_depth = base_layer_projection_depth; 262 260 cb->base.base.layer_quad = base_layer_quad; 263 261 cb->base.base.layer_cube = base_layer_cube; 264 262 cb->base.base.layer_cylinder = base_layer_cylinder;

+11 -10

src/xrt/compositor/util/comp_render_cs.c

··· 131 131 ubo_data->images_samplers[cur_layer + 0].images[0] = cur_image++; 132 132 133 133 // Depth 134 134 - if (data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH) { 134 134 + if (data->type == XRT_LAYER_PROJECTION_DEPTH) { 135 135 uint32_t d_array_index = dvd->sub.array_index; 136 136 const struct comp_swapchain_image *d_image = 137 137 &layer->sc_array[sc_array_index + 2]->images[dvd->sub.image_index]; ··· 324 324 } 325 325 326 326 struct render_viewport_data target_viewport_datas[XRT_MAX_VIEWS]; 327 327 - for (uint32_t i = 0; i < crc->r->view_count; ++i) { 327 327 + for (uint32_t i = 0; i < d->view_count; ++i) { 328 328 target_viewport_datas[i] = d->views[i].target_viewport_data; 329 329 } 330 330 ··· 525 525 case XRT_LAYER_CYLINDER: required_image_samplers = 1; break; 526 526 case XRT_LAYER_EQUIRECT2: required_image_samplers = 1; break; 527 527 case XRT_LAYER_PROJECTION: required_image_samplers = 1; break; 528 528 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: required_image_samplers = 2; break; 528 528 + case XRT_LAYER_PROJECTION_DEPTH: required_image_samplers = 2; break; 529 529 case XRT_LAYER_QUAD: required_image_samplers = 1; break; 530 530 default: 531 531 VK_ERROR(crc->r->vk, "Skipping layer #%u, unknown type: %u", c_layer_i, data->type); ··· 570 570 ubo_data, // ubo_data 571 571 &cur_image); // out_cur_image 572 572 break; 573 573 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: 573 573 + case XRT_LAYER_PROJECTION_DEPTH: 574 574 case XRT_LAYER_PROJECTION: { 575 575 do_cs_projection_layer( // 576 576 data, // data ··· 711 711 const struct comp_layer *layer = &layers[i]; 712 712 const struct xrt_layer_projection_data *proj = &layer->data.proj; 713 713 const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 714 714 - for (uint32_t view = 0; view < crc->r->view_count; ++view) { 714 714 + for (uint32_t view = 0; view < d->view_count; ++view) { 715 715 vds[view] = &proj->v[view]; 716 716 } 717 717 do_cs_distortion_for_layer( // ··· 719 719 layer, // layer 720 720 vds, // vds 721 721 d); // d 722 722 - } else if (fast_path && layers[0].data.type == XRT_LAYER_STEREO_PROJECTION_DEPTH) { 722 722 + } else if (fast_path && layers[0].data.type == XRT_LAYER_PROJECTION_DEPTH) { 723 723 int i = 0; 724 724 const struct comp_layer *layer = &layers[i]; 725 725 - const struct xrt_layer_stereo_projection_depth_data *stereo = &layer->data.stereo_depth; 726 726 - const struct xrt_layer_projection_view_data *vds[2]; 727 727 - vds[0] = &stereo->l; 728 728 - vds[1] = &stereo->r; 725 725 + const struct xrt_layer_projection_depth_data *depth = &layer->data.depth; 726 726 + const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 727 727 + for (uint32_t view = 0; view < d->view_count; ++view) { 728 728 + vds[view] = &depth->v[view]; 729 729 + } 729 730 do_cs_distortion_for_layer( // 730 731 crc, // crc 731 732 layer, // layer

+8 -7

src/xrt/compositor/util/comp_render_gfx.c

··· 562 562 VK_CHK_WITH_GOTO(ret, "do_equirect2_layer", err_layer); 563 563 break; 564 564 case XRT_LAYER_PROJECTION: 565 565 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: 565 565 + case XRT_LAYER_PROJECTION_DEPTH: 566 566 ret = do_projection_layer( // 567 567 rr, // rr 568 568 &layers[i], // layer ··· 627 627 state->descriptor_sets[i]); // 628 628 break; 629 629 case XRT_LAYER_PROJECTION: 630 630 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: 630 630 + case XRT_LAYER_PROJECTION_DEPTH: 631 631 render_gfx_layer_projection( // 632 632 rr, // 633 633 state->premultiplied_alphas[i], // ··· 827 827 layer, // 828 828 vds); // 829 829 830 830 - } else if (fast_path && layer->data.type == XRT_LAYER_STEREO_PROJECTION_DEPTH) { 830 830 + } else if (fast_path && layer->data.type == XRT_LAYER_PROJECTION_DEPTH) { 831 831 // Fast path. 832 832 - const struct xrt_layer_stereo_projection_depth_data *stereo = &layer->data.stereo_depth; 833 833 - const struct xrt_layer_projection_view_data *vds[2]; 834 834 - vds[0] = &stereo->l; 835 835 - vds[1] = &stereo->r; 832 832 + const struct xrt_layer_projection_depth_data *depth = &layer->data.depth; 833 833 + const struct xrt_layer_projection_view_data *vds[XRT_MAX_VIEWS]; 834 834 + for (uint32_t view = 0; view < d->view_count; ++view) { 835 835 + vds[view] = &depth->v[view]; 836 836 + } 836 837 do_mesh_from_proj( // 837 838 rr, // 838 839 d, //

+5 -16

src/xrt/compositor/util/comp_render_helpers.h

··· 52 52 const struct xrt_layer_projection_view_data **out_vd) 53 53 { 54 54 const struct xrt_layer_projection_data *proj = &data->proj; 55 55 - 56 56 - if (is_view_index_right(view_index)) { 57 57 - *out_vd = &proj->v[view_index]; 58 58 - } else { 59 59 - *out_vd = &proj->v[view_index]; 60 60 - } 55 55 + *out_vd = &proj->v[view_index]; 61 56 } 62 57 63 58 static inline void ··· 66 61 const struct xrt_layer_projection_view_data **out_vd, 67 62 const struct xrt_layer_depth_data **out_dvd) 68 63 { 69 69 - const struct xrt_layer_stereo_projection_depth_data *stereo = &data->stereo_depth; 70 70 - 71 71 - if (is_view_index_right(view_index)) { 72 72 - *out_vd = &stereo->r; 73 73 - *out_dvd = &stereo->r_d; 74 74 - } else { 75 75 - *out_vd = &stereo->l; 76 76 - *out_dvd = &stereo->l_d; 77 77 - } 64 64 + const struct xrt_layer_projection_depth_data *depth = &data->depth; 65 65 + *out_vd = &depth->v[view_index]; 66 66 + *out_dvd = &depth->d[view_index]; 78 67 } 79 68 80 69 ··· 95 84 case XRT_LAYER_EQUIRECT2: visibility = data->equirect2.visibility; break; 96 85 case XRT_LAYER_QUAD: visibility = data->quad.visibility; break; 97 86 case XRT_LAYER_PROJECTION: 98 98 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: return true; 87 87 + case XRT_LAYER_PROJECTION_DEPTH: return true; 99 88 default: return false; 100 89 }; 101 90

+22 -26

src/xrt/include/xrt/xrt_compositor.h

··· 76 76 enum xrt_layer_type 77 77 { 78 78 XRT_LAYER_PROJECTION, 79 79 - XRT_LAYER_STEREO_PROJECTION_DEPTH, 79 79 + XRT_LAYER_PROJECTION_DEPTH, 80 80 XRT_LAYER_QUAD, 81 81 XRT_LAYER_CUBE, 82 82 XRT_LAYER_CYLINDER, ··· 223 223 }; 224 224 225 225 /*! 226 226 - * All the pure data values associated with a stereo projection layer. 226 226 + * All the pure data values associated with a projection layer. 227 227 * 228 228 * The @ref xrt_swapchain references and @ref xrt_device are provided outside of 229 229 * this struct. 230 230 */ 231 231 struct xrt_layer_projection_data 232 232 { 233 233 - uint32_t view_count; 234 233 struct xrt_layer_projection_view_data v[XRT_MAX_VIEWS]; 235 234 }; 236 235 ··· 258 257 }; 259 258 260 259 /*! 261 261 - * All the pure data values associated with a stereo projection layer with depth 260 260 + * All the pure data values associated with a projection layer with depth 262 261 * swapchain attached. 263 262 * 264 263 * The @ref xrt_swapchain references and @ref xrt_device are provided outside of 265 264 * this struct. 266 265 */ 267 267 - struct xrt_layer_stereo_projection_depth_data 266 266 + struct xrt_layer_projection_depth_data 268 267 { 269 269 - struct xrt_layer_projection_view_data l, r; 268 268 + struct xrt_layer_projection_view_data v[XRT_MAX_VIEWS]; 270 269 271 271 - struct xrt_layer_depth_data l_d, r_d; 270 270 + struct xrt_layer_depth_data d[XRT_MAX_VIEWS]; 272 271 }; 273 272 274 273 /*! ··· 460 459 */ 461 460 union { 462 461 struct xrt_layer_projection_data proj; 463 463 - struct xrt_layer_stereo_projection_depth_data stereo_depth; 462 462 + struct xrt_layer_projection_depth_data depth; 464 463 struct xrt_layer_quad_data quad; 465 464 struct xrt_layer_cube_data cube; 466 465 struct xrt_layer_cylinder_data cylinder; ··· 468 467 struct xrt_layer_equirect2_data equirect2; 469 468 struct xrt_layer_passthrough_data passthrough; 470 469 }; 470 470 + uint32_t view_count; 471 471 }; 472 472 473 473 /*! ··· 1197 1197 xrt_result_t (*layer_begin)(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data); 1198 1198 1199 1199 /*! 1200 1200 - * @brief Adds a stereo projection layer for submissions. 1200 1200 + * @brief Adds a projection layer for submissions. 1201 1201 * 1202 1202 * Note that e.g. the same swapchain object may be passed as both 1203 1203 * @p l_xsc and @p r_xsc - the parameters in @p data identify ··· 1216 1216 const struct xrt_layer_data *data); 1217 1217 1218 1218 /*! 1219 1219 - * @brief Adds a stereo projection layer for submission, has depth information. 1219 1219 + * @brief Adds a projection layer for submission, has depth information. 1220 1220 * 1221 1221 * Note that e.g. the same swapchain object may be passed as both 1222 1222 * @p l_xsc and @p r_xsc - the parameters in @p data identify ··· 1234 1234 * including what parts of the supplied swapchain 1235 1235 * objects to use for each view. 1236 1236 */ 1237 1237 - xrt_result_t (*layer_stereo_projection_depth)(struct xrt_compositor *xc, 1238 1238 - struct xrt_device *xdev, 1239 1239 - struct xrt_swapchain *l_xsc, 1240 1240 - struct xrt_swapchain *r_xsc, 1241 1241 - struct xrt_swapchain *l_d_xsc, 1242 1242 - struct xrt_swapchain *r_d_xsc, 1243 1243 - const struct xrt_layer_data *data); 1237 1237 + xrt_result_t (*layer_projection_depth)(struct xrt_compositor *xc, 1238 1238 + struct xrt_device *xdev, 1239 1239 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 1240 1240 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 1241 1241 + const struct xrt_layer_data *data); 1244 1242 1245 1243 /*! 1246 1244 * Adds a quad layer for submission, the center of the quad is specified ··· 1695 1693 } 1696 1694 1697 1695 /*! 1698 1698 - * @copydoc xrt_compositor::layer_stereo_projection_depth 1696 1696 + * @copydoc xrt_compositor::layer_projection_depth 1699 1697 * 1700 1698 * Helper for calling through the function pointer. 1701 1699 * 1702 1700 * @public @memberof xrt_compositor 1703 1701 */ 1704 1702 static inline xrt_result_t 1705 1705 - xrt_comp_layer_stereo_projection_depth(struct xrt_compositor *xc, 1706 1706 - struct xrt_device *xdev, 1707 1707 - struct xrt_swapchain *l_xsc, 1708 1708 - struct xrt_swapchain *r_xsc, 1709 1709 - struct xrt_swapchain *l_d_xsc, 1710 1710 - struct xrt_swapchain *r_d_xsc, 1711 1711 - const struct xrt_layer_data *data) 1703 1703 + xrt_comp_layer_projection_depth(struct xrt_compositor *xc, 1704 1704 + struct xrt_device *xdev, 1705 1705 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 1706 1706 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 1707 1707 + const struct xrt_layer_data *data) 1712 1708 { 1713 1713 - return xc->layer_stereo_projection_depth(xc, xdev, l_xsc, r_xsc, l_d_xsc, r_d_xsc, data); 1709 1709 + return xc->layer_projection_depth(xc, xdev, xsc, d_xsc, data); 1714 1710 } 1715 1711 1716 1712 /*!

+18 -18

src/xrt/ipc/client/ipc_client_compositor.c

··· 595 595 struct ipc_layer_entry *layer = &slot->layers[icc->layers.layer_count]; 596 596 layer->xdev_id = 0; //! @todo Real id. 597 597 layer->data = *data; 598 598 - for (uint32_t i = 0; i < data->proj.view_count; ++i) { 598 598 + for (uint32_t i = 0; i < data->view_count; ++i) { 599 599 struct ipc_client_swapchain *ics = ipc_client_swapchain(xsc[i]); 600 600 layer->swapchain_ids[i] = ics->id; 601 601 } ··· 606 606 } 607 607 608 608 static xrt_result_t 609 609 - ipc_compositor_layer_stereo_projection_depth(struct xrt_compositor *xc, 610 610 - struct xrt_device *xdev, 611 611 - struct xrt_swapchain *l_xsc, 612 612 - struct xrt_swapchain *r_xsc, 613 613 - struct xrt_swapchain *l_d_xsc, 614 614 - struct xrt_swapchain *r_d_xsc, 615 615 - const struct xrt_layer_data *data) 609 609 + ipc_compositor_layer_projection_depth(struct xrt_compositor *xc, 610 610 + struct xrt_device *xdev, 611 611 + struct xrt_swapchain *xsc[XRT_MAX_VIEWS], 612 612 + struct xrt_swapchain *d_xsc[XRT_MAX_VIEWS], 613 613 + const struct xrt_layer_data *data) 616 614 { 617 615 struct ipc_client_compositor *icc = ipc_client_compositor(xc); 618 616 619 619 - assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH); 617 617 + assert(data->type == XRT_LAYER_PROJECTION_DEPTH); 620 618 621 619 struct ipc_shared_memory *ism = icc->ipc_c->ism; 622 620 struct ipc_layer_slot *slot = &ism->slots[icc->layers.slot_id]; 623 621 struct ipc_layer_entry *layer = &slot->layers[icc->layers.layer_count]; 624 624 - struct ipc_client_swapchain *l = ipc_client_swapchain(l_xsc); 625 625 - struct ipc_client_swapchain *r = ipc_client_swapchain(r_xsc); 626 626 - struct ipc_client_swapchain *l_d = ipc_client_swapchain(l_d_xsc); 627 627 - struct ipc_client_swapchain *r_d = ipc_client_swapchain(r_d_xsc); 622 622 + struct ipc_client_swapchain *xscn[XRT_MAX_VIEWS]; 623 623 + struct ipc_client_swapchain *d_xscn[XRT_MAX_VIEWS]; 624 624 + for (uint32_t i = 0; i < data->view_count; ++i) { 625 625 + xscn[i] = ipc_client_swapchain(xsc[i]); 626 626 + d_xscn[i] = ipc_client_swapchain(d_xsc[i]); 627 627 + 628 628 + layer->swapchain_ids[i] = xscn[i]->id; 629 629 + layer->swapchain_ids[i + data->view_count] = d_xscn[i]->id; 630 630 + } 628 631 629 632 layer->xdev_id = 0; //! @todo Real id. 630 630 - layer->swapchain_ids[0] = l->id; 631 631 - layer->swapchain_ids[1] = r->id; 632 632 - layer->swapchain_ids[2] = l_d->id; 633 633 - layer->swapchain_ids[3] = r_d->id; 633 633 + 634 634 layer->data = *data; 635 635 636 636 // Increment the number of layers. ··· 885 885 icc->base.base.discard_frame = ipc_compositor_discard_frame; 886 886 icc->base.base.layer_begin = ipc_compositor_layer_begin; 887 887 icc->base.base.layer_projection = ipc_compositor_layer_projection; 888 888 - icc->base.base.layer_stereo_projection_depth = ipc_compositor_layer_stereo_projection_depth; 888 888 + icc->base.base.layer_projection_depth = ipc_compositor_layer_projection_depth; 889 889 icc->base.base.layer_quad = ipc_compositor_layer_quad; 890 890 icc->base.base.layer_cube = ipc_compositor_layer_cube; 891 891 icc->base.base.layer_cylinder = ipc_compositor_layer_cylinder;

+19 -22

src/xrt/ipc/server/ipc_server_handler.c

··· 775 775 { 776 776 // xdev 777 777 uint32_t xdevi = layer->xdev_id; 778 778 - // left 779 779 - uint32_t l_xsci = layer->swapchain_ids[0]; 780 780 - // right 781 781 - uint32_t r_xsci = layer->swapchain_ids[1]; 782 782 - // left 783 783 - uint32_t l_d_xsci = layer->swapchain_ids[2]; 784 784 - // right 785 785 - uint32_t r_d_xsci = layer->swapchain_ids[3]; 786 778 787 787 - struct xrt_device *xdev = get_xdev(ics, xdevi); 788 788 - struct xrt_swapchain *l_xcs = ics->xscs[l_xsci]; 789 789 - struct xrt_swapchain *r_xcs = ics->xscs[r_xsci]; 790 790 - struct xrt_swapchain *l_d_xcs = ics->xscs[l_d_xsci]; 791 791 - struct xrt_swapchain *r_d_xcs = ics->xscs[r_d_xsci]; 779 779 + // Cast away volatile. 780 780 + struct xrt_layer_data *data = (struct xrt_layer_data *)&layer->data; 792 781 793 793 - if (l_xcs == NULL || r_xcs == NULL || l_d_xcs == NULL || r_d_xcs == NULL) { 794 794 - U_LOG_E("Invalid swap chain for projection layer #%u!", i); 795 795 - return false; 796 796 - } 797 797 - 782 782 + struct xrt_device *xdev = get_xdev(ics, xdevi); 798 783 if (xdev == NULL) { 799 784 U_LOG_E("Invalid xdev for projection layer #%u!", i); 800 785 return false; 801 786 } 802 787 803 803 - // Cast away volatile. 804 804 - struct xrt_layer_data *data = (struct xrt_layer_data *)&layer->data; 788 788 + struct xrt_swapchain *xcs[XRT_MAX_VIEWS]; 789 789 + struct xrt_swapchain *d_xcs[XRT_MAX_VIEWS]; 790 790 + 791 791 + for (uint32_t j = 0; j < data->view_count; j++) { 792 792 + int xsci = layer->swapchain_ids[j]; 793 793 + int d_xsci = layer->swapchain_ids[j + data->view_count]; 794 794 + 795 795 + xcs[j] = ics->xscs[xsci]; 796 796 + d_xcs[j] = ics->xscs[d_xsci]; 797 797 + if (xcs[j] == NULL || d_xcs[j] == NULL) { 798 798 + U_LOG_E("Invalid swap chain for projection layer #%u!", i); 799 799 + return false; 800 800 + } 801 801 + } 805 802 806 806 - xrt_comp_layer_stereo_projection_depth(xc, xdev, l_xcs, r_xcs, l_d_xcs, r_d_xcs, data); 803 803 + xrt_comp_layer_projection_depth(xc, xdev, xcs, d_xcs, data); 807 804 808 805 return true; 809 806 } ··· 977 974 return false; 978 975 } 979 976 break; 980 980 - case XRT_LAYER_STEREO_PROJECTION_DEPTH: 977 977 + case XRT_LAYER_PROJECTION_DEPTH: 981 978 if (!_update_projection_layer_depth(xc, ics, layer, i)) { 982 979 return false; 983 980 }

+35 -48

src/xrt/state_trackers/oxr/oxr_session_frame_end.c

··· 694 694 } 695 695 696 696 #ifdef OXR_HAVE_KHR_composition_layer_depth 697 697 - if (depth_layer_count > 0 && depth_layer_count != proj->viewCount && proj->viewCount != 2) { 697 697 + if (depth_layer_count > 0 && depth_layer_count != proj->viewCount) { 698 698 return oxr_error( 699 699 log, XR_ERROR_VALIDATION_FAILURE, 700 700 "(frameEndInfo->layers[%u] projection layer must have %u depth layers or none, but has: %u)", ··· 1258 1258 uint64_t xrt_timestamp) 1259 1259 { 1260 1260 struct oxr_space *spc = XRT_CAST_OXR_HANDLE_TO_PTR(struct oxr_space *, proj->space); 1261 1261 - struct oxr_swapchain *d_scs[2] = {NULL, NULL}; 1261 1261 + struct oxr_swapchain *d_scs[XRT_MAX_VIEWS]; 1262 1262 struct oxr_swapchain *scs[XRT_MAX_VIEWS]; 1263 1263 struct xrt_pose *pose_ptr; 1264 1264 struct xrt_pose pose[XRT_MAX_VIEWS]; 1265 1265 struct xrt_swapchain *swapchains[XRT_MAX_VIEWS]; 1266 1266 + struct xrt_swapchain *d_swapchains[XRT_MAX_VIEWS]; 1266 1267 1267 1268 enum xrt_layer_composition_flags flags = convert_layer_flags(proj->layerFlags); 1268 1269 ··· 1286 1287 data.name = XRT_INPUT_GENERIC_HEAD_POSE; 1287 1288 data.timestamp = xrt_timestamp; 1288 1289 data.flags = flags; 1289 1289 - data.proj.view_count = proj->viewCount; 1290 1290 + data.view_count = proj->viewCount; 1290 1291 for (size_t i = 0; i < proj->viewCount; ++i) { 1291 1292 struct xrt_fov *fov = (struct xrt_fov *)&proj->views[i].fov; 1292 1293 data.proj.v[i].fov = *fov; ··· 1298 1299 fill_in_y_flip(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1299 1300 fill_in_blend_factors(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1300 1301 fill_in_layer_settings(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1301 1301 - 1302 1302 1303 1303 #ifdef OXR_HAVE_KHR_composition_layer_depth 1304 1304 - if (proj->viewCount == 2) { 1305 1305 - const XrCompositionLayerDepthInfoKHR *d_l = OXR_GET_INPUT_FROM_CHAIN( 1306 1306 - &proj->views[0], XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR, XrCompositionLayerDepthInfoKHR); 1307 1307 - if (d_l) { 1308 1308 - data.stereo_depth.l_d.far_z = d_l->farZ; 1309 1309 - data.stereo_depth.l_d.near_z = d_l->nearZ; 1310 1310 - data.stereo_depth.l_d.max_depth = d_l->maxDepth; 1311 1311 - data.stereo_depth.l_d.min_depth = d_l->minDepth; 1312 1312 - 1304 1304 + // number of depth layers must be 0 or proj->viewCount 1305 1305 + const XrCompositionLayerDepthInfoKHR *d_is[XRT_MAX_VIEWS]; 1306 1306 + for (uint32_t i = 0; i < proj->viewCount; ++i) { 1307 1307 + d_scs[i] = NULL; 1308 1308 + d_is[i] = OXR_GET_INPUT_FROM_CHAIN(&proj->views[i], XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR, 1309 1309 + XrCompositionLayerDepthInfoKHR); 1310 1310 + if (d_is[i]) { 1311 1311 + data.depth.d[i].far_z = d_is[i]->farZ; 1312 1312 + data.depth.d[i].near_z = d_is[i]->nearZ; 1313 1313 + data.depth.d[i].max_depth = d_is[i]->maxDepth; 1314 1314 + data.depth.d[i].min_depth = d_is[i]->minDepth; 1313 1315 struct oxr_swapchain *sc = 1314 1314 - XRT_CAST_OXR_HANDLE_TO_PTR(struct oxr_swapchain *, d_l->subImage.swapchain); 1315 1315 - 1316 1316 - fill_in_sub_image(sc, &d_l->subImage, &data.stereo_depth.l_d.sub); 1317 1317 - 1318 1318 - // Need to pass this in. 1319 1319 - d_scs[0] = sc; 1316 1316 + XRT_CAST_OXR_HANDLE_TO_PTR(struct oxr_swapchain *, d_is[i]->subImage.swapchain); 1317 1317 + fill_in_sub_image(sc, &d_is[i]->subImage, &data.depth.d[i].sub); 1318 1318 + d_scs[i] = sc; 1319 1319 + d_swapchains[i] = sc->swapchain; 1320 1320 } 1321 1321 - 1322 1322 - const XrCompositionLayerDepthInfoKHR *d_r = OXR_GET_INPUT_FROM_CHAIN( 1323 1323 - &proj->views[1], XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR, XrCompositionLayerDepthInfoKHR); 1324 1324 - 1325 1325 - if (d_r) { 1326 1326 - data.stereo_depth.r_d.far_z = d_r->farZ; 1327 1327 - data.stereo_depth.r_d.near_z = d_r->nearZ; 1328 1328 - data.stereo_depth.r_d.max_depth = d_r->maxDepth; 1329 1329 - data.stereo_depth.r_d.min_depth = d_r->minDepth; 1330 1330 - 1331 1331 - struct oxr_swapchain *sc = 1332 1332 - XRT_CAST_OXR_HANDLE_TO_PTR(struct oxr_swapchain *, d_r->subImage.swapchain); 1333 1333 - 1334 1334 - fill_in_sub_image(sc, &d_r->subImage, &data.stereo_depth.r_d.sub); 1335 1335 - 1336 1336 - // Need to pass this in. 1337 1337 - d_scs[1] = sc; 1321 1321 + } 1322 1322 + #endif // OXR_HAVE_KHR_composition_layer_depth 1323 1323 + bool d_scs_valid = true; 1324 1324 + for (uint32_t i = 0; i < proj->viewCount; i++) { 1325 1325 + if (d_scs[i] == NULL) { 1326 1326 + d_scs_valid = false; 1327 1327 + break; 1338 1328 } 1339 1329 } 1340 1340 - #endif // OXR_HAVE_KHR_composition_layer_depth 1341 1341 - if (d_scs[0] != NULL && d_scs[1] != NULL) { 1330 1330 + if (d_scs_valid) { 1342 1331 #ifdef OXR_HAVE_KHR_composition_layer_depth 1343 1332 fill_in_depth_test(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1344 1344 - data.type = XRT_LAYER_STEREO_PROJECTION_DEPTH; 1345 1345 - xrt_result_t xret = xrt_comp_layer_stereo_projection_depth( // 1346 1346 - xc, // compositor 1347 1347 - head, // xdev 1348 1348 - scs[0]->swapchain, // left 1349 1349 - scs[1]->swapchain, // right 1350 1350 - d_scs[0]->swapchain, // left 1351 1351 - d_scs[1]->swapchain, // right 1352 1352 - &data); // data 1353 1353 - OXR_CHECK_XRET(log, sess, xret, xrt_comp_layer_stereo_projection_depth); 1333 1333 + data.type = XRT_LAYER_PROJECTION_DEPTH; 1334 1334 + xrt_result_t xret = xrt_comp_layer_projection_depth( // 1335 1335 + xc, // compositor 1336 1336 + head, // xdev 1337 1337 + swapchains, // swapchains 1338 1338 + d_swapchains, // depth swapchains 1339 1339 + &data); // data 1340 1340 + OXR_CHECK_XRET(log, sess, xret, xrt_comp_layer_projection_depth); 1354 1341 #else 1355 1342 assert(false && "Should not get here"); 1356 1343 #endif // OXR_HAVE_KHR_composition_layer_depth

+1 -1

src/xrt/targets/sdl_test/sdl_program.cpp

··· 116 116 glClearColor(0.2f, 0.2f, 0.2f, 0.0f); 117 117 glClear(GL_COLOR_BUFFER_BIT); 118 118 } else if (spp.c.base.slot.layers[0].data.type == XRT_LAYER_PROJECTION || 119 119 - spp.c.base.slot.layers[0].data.type == XRT_LAYER_STEREO_PROJECTION_DEPTH) { 119 119 + spp.c.base.slot.layers[0].data.type == XRT_LAYER_PROJECTION_DEPTH) { 120 120 121 121 auto &l = spp.c.base.slot.layers[0]; 122 122 auto &ssc = *(sdl_swapchain *)l.sc_array[0];