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

Configure Feed

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

st/oxr: Add extension XR_FB_composition_layer_alpha_blend

authored by

jialz and committed by
Jakob Bornecrantz e51ecede 6bdfb155

+204 -13
+4
CMakeLists.txt
··· 431 431 if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_EQUIRECT1) 432 432 set(XRT_FEATURE_OPENXR_LAYER_EQUIRECT1 OFF) 433 433 endif() 434 + if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND) 435 + set(XRT_FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND OFF) 436 + endif() 434 437 if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT) 435 438 set(XRT_FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT ON) 436 439 endif() ··· 649 652 message(STATUS "# FEATURE_OPENXR_LAYER_DEPTH: ${XRT_FEATURE_OPENXR_LAYER_DEPTH}") 650 653 message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT1: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT1}") 651 654 message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT2: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT2}") 655 + message(STATUS "# FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND: ${XRT_FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND}") 652 656 message(STATUS "# FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT ${XRT_FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT}") 653 657 message(STATUS "# FEATURE_OPENXR_LAYER_FB_SETTINGS: ${XRT_FEATURE_OPENXR_LAYER_FB_SETTINGS}") 654 658 message(STATUS "# FEATURE_OPENXR_OVERLAY: ${XRT_FEATURE_OPENXR_OVERLAY}")
+1
scripts/generate_oxr_ext_support.py
··· 64 64 ['XR_EXT_local_floor', 'XRT_FEATURE_OPENXR_SPACE_LOCAL_FLOOR'], 65 65 ['XR_EXT_palm_pose', 'XRT_FEATURE_OPENXR_INTERACTION_EXT_PALM_POSE'], 66 66 ['XR_EXT_samsung_odyssey_controller', 'XRT_FEATURE_OPENXR_INTERACTION_WINMR'], 67 + ['XR_FB_composition_layer_alpha_blend', 'XRT_FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND'], 67 68 ['XR_FB_composition_layer_image_layout', 'XRT_FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT'], 68 69 ['XR_FB_composition_layer_settings', 'XRT_FEATURE_OPENXR_LAYER_FB_SETTINGS'], 69 70 ['XR_FB_display_refresh_rate', 'XRT_FEATURE_OPENXR_DISPLAY_REFRESH_RATE'],
+9
src/xrt/auxiliary/util/u_verify.h
··· 12 12 #pragma once 13 13 #include "xrt/xrt_defines.h" 14 14 #include "xrt/xrt_device.h" 15 + #include "xrt/xrt_compositor.h" 15 16 16 17 static inline bool 17 18 u_verify_blend_mode_valid(enum xrt_blend_mode blend_mode) ··· 30 31 } 31 32 return false; 32 33 } 34 + 35 + static inline bool 36 + u_verify_blend_factor_valid(enum xrt_blend_factor blend_factor) 37 + { 38 + return (blend_factor == XRT_BLEND_FACTOR_ZERO) || (blend_factor == XRT_BLEND_FACTOR_ONE) || 39 + (blend_factor == XRT_BLEND_FACTOR_SRC_ALPHA) || (blend_factor == XRT_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA) || 40 + (blend_factor == XRT_BLEND_FACTOR_DST_ALPHA) || (blend_factor == XRT_BLEND_FACTOR_ONE_MINUS_DST_ALPHA); 41 + }
+42
src/xrt/include/xrt/xrt_compositor.h
··· 115 115 116 116 //! Quality sharpening, see XrCompositionLayerSettingsFlagsFB. 117 117 XRT_COMPOSITION_LAYER_PROCESSING_QUALITY_SHARPENING_BIT_FB = 1u << 8u, 118 + 119 + /*! 120 + * This layer has advanced blending information, this bit 121 + * supersedes the behavior of 122 + * @ref XRT_LAYER_COMPOSITION_BLEND_TEXTURE_SOURCE_ALPHA_BIT, 123 + * see @p XrCompositionLayerAlphaBlendFB. 124 + */ 125 + XRT_LAYER_COMPOSITION_ADVANCED_BLENDING_BIT = 1u << 9u, 118 126 }; 119 127 120 128 /*! ··· 130 138 XRT_LAYER_EYE_VISIBILITY_LEFT_BIT = 0x1, 131 139 XRT_LAYER_EYE_VISIBILITY_RIGHT_BIT = 0x2, 132 140 XRT_LAYER_EYE_VISIBILITY_BOTH = 0x3, 141 + }; 142 + 143 + /*! 144 + * Blend factors. 145 + */ 146 + enum xrt_blend_factor 147 + { 148 + XRT_BLEND_FACTOR_ZERO = 0, 149 + XRT_BLEND_FACTOR_ONE = 1, 150 + XRT_BLEND_FACTOR_SRC_ALPHA = 2, 151 + XRT_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 3, 152 + XRT_BLEND_FACTOR_DST_ALPHA = 4, 153 + XRT_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 5, 154 + XRT_BLEND_FACTOR_MAX_ENUM_FB = 0x7FFFFFFF, 155 + }; 156 + 157 + /*! 158 + * Advanced blend 159 + * provides explicit control over source and destination blend factors, 160 + * with separate controls for color and alpha 161 + * 162 + * See @ref XRT_LAYER_COMPOSITION_ADVANCED_BLENDING_BIT. 163 + */ 164 + struct xrt_layer_advanced_blend_data 165 + { 166 + enum xrt_blend_factor src_factor_color; 167 + enum xrt_blend_factor dst_factor_color; 168 + enum xrt_blend_factor src_factor_alpha; 169 + enum xrt_blend_factor dst_factor_alpha; 133 170 }; 134 171 135 172 /*! ··· 344 381 * Modulate the color sourced from the images. 345 382 */ 346 383 struct xrt_colour_rgba_f32 color_bias; 384 + 385 + /*! 386 + * Advanced blend factors 387 + */ 388 + struct xrt_layer_advanced_blend_data advanced_blend; 347 389 348 390 /*! 349 391 * Union of data values for the various layer types.
+1
src/xrt/include/xrt/xrt_config_build.h.cmake_in
··· 46 46 #cmakedefine XRT_FEATURE_OPENXR_LAYER_DEPTH 47 47 #cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT1 48 48 #cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT2 49 + #cmakedefine XRT_FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND 49 50 #cmakedefine XRT_FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT 50 51 #cmakedefine XRT_FEATURE_OPENXR_LAYER_FB_SETTINGS 51 52 #cmakedefine XRT_FEATURE_OPENXR_OVERLAY
+13
src/xrt/state_trackers/oxr/oxr_extension_support.h
··· 373 373 374 374 375 375 /* 376 + * XR_FB_composition_layer_alpha_blend 377 + */ 378 + #if defined(XR_FB_composition_layer_alpha_blend) && defined(XRT_FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND) 379 + #define OXR_HAVE_FB_composition_layer_alpha_blend 380 + #define OXR_EXTENSION_SUPPORT_FB_composition_layer_alpha_blend(_) \ 381 + _(FB_composition_layer_alpha_blend, FB_COMPOSITION_LAYER_ALPHA_BLEND) 382 + #else 383 + #define OXR_EXTENSION_SUPPORT_FB_composition_layer_alpha_blend(_) 384 + #endif 385 + 386 + 387 + /* 376 388 * XR_FB_composition_layer_image_layout 377 389 */ 378 390 #if defined(XR_FB_composition_layer_image_layout) && defined(XRT_FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT) ··· 609 621 OXR_EXTENSION_SUPPORT_EXT_local_floor(_) \ 610 622 OXR_EXTENSION_SUPPORT_EXT_palm_pose(_) \ 611 623 OXR_EXTENSION_SUPPORT_EXT_samsung_odyssey_controller(_) \ 624 + OXR_EXTENSION_SUPPORT_FB_composition_layer_alpha_blend(_) \ 612 625 OXR_EXTENSION_SUPPORT_FB_composition_layer_image_layout(_) \ 613 626 OXR_EXTENSION_SUPPORT_FB_composition_layer_settings(_) \ 614 627 OXR_EXTENSION_SUPPORT_FB_display_refresh_rate(_) \
+134 -13
src/xrt/state_trackers/oxr/oxr_session_frame_end.c
··· 95 95 } 96 96 } 97 97 98 + #ifdef OXR_HAVE_FB_composition_layer_alpha_blend 99 + static enum xrt_blend_factor 100 + convert_blend_factor(XrBlendFactorFB blend_factor) 101 + { 102 + switch (blend_factor) { 103 + case XR_BLEND_FACTOR_ZERO_FB: return XRT_BLEND_FACTOR_ZERO; 104 + case XR_BLEND_FACTOR_ONE_FB: return XRT_BLEND_FACTOR_ONE; 105 + case XR_BLEND_FACTOR_SRC_ALPHA_FB: return XRT_BLEND_FACTOR_SRC_ALPHA; 106 + case XR_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA_FB: return XRT_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; 107 + case XR_BLEND_FACTOR_DST_ALPHA_FB: return XRT_BLEND_FACTOR_DST_ALPHA; 108 + case XR_BLEND_FACTOR_ONE_MINUS_DST_ALPHA_FB: return XRT_BLEND_FACTOR_ONE_MINUS_DST_ALPHA; 109 + default: return XRT_BLEND_FACTOR_MAX_ENUM_FB; 110 + } 111 + } 112 + #endif // OXR_HAVE_FB_composition_layer_alpha_blend 113 + 98 114 static enum xrt_layer_composition_flags 99 115 convert_layer_flags(XrSwapchainUsageFlags xr_flags) 100 116 { ··· 226 242 } 227 243 228 244 static void 245 + fill_in_blend_factors(struct oxr_session *sess, const XrCompositionLayerBaseHeader *layer, struct xrt_layer_data *data) 246 + { 247 + #ifdef OXR_HAVE_FB_composition_layer_alpha_blend 248 + // Is the extension enabled? 249 + if (!sess->sys->inst->extensions.FB_composition_layer_alpha_blend) { 250 + return; 251 + } 252 + const XrCompositionLayerAlphaBlendFB *alphaBlend = OXR_GET_INPUT_FROM_CHAIN( 253 + layer, (XrStructureType)XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB, XrCompositionLayerAlphaBlendFB); 254 + if (alphaBlend != NULL) { 255 + data->flags |= XRT_LAYER_COMPOSITION_ADVANCED_BLENDING_BIT; 256 + data->advanced_blend.src_factor_color = convert_blend_factor(alphaBlend->srcFactorColor); 257 + data->advanced_blend.dst_factor_color = convert_blend_factor(alphaBlend->dstFactorColor); 258 + data->advanced_blend.src_factor_alpha = convert_blend_factor(alphaBlend->srcFactorAlpha); 259 + data->advanced_blend.dst_factor_alpha = convert_blend_factor(alphaBlend->dstFactorAlpha); 260 + } 261 + #endif 262 + } 263 + 264 + static void 229 265 fill_in_layer_settings(struct oxr_session *sess, 230 266 const XrCompositionLayerBaseHeader *layer, 231 267 struct xrt_layer_data *xlayer_data) ··· 243 279 #endif // OXR_HAVE_FB_composition_layer_settings 244 280 } 245 281 282 + 246 283 /* 247 284 * 248 285 * Verify functions. ··· 250 287 */ 251 288 252 289 static XrResult 290 + verify_blend_factors(struct oxr_logger *log, 291 + struct oxr_session *sess, 292 + uint32_t layer_index, 293 + const XrCompositionLayerBaseHeader *layer) 294 + { 295 + #ifdef OXR_HAVE_FB_composition_layer_alpha_blend 296 + if (!sess->sys->inst->extensions.FB_composition_layer_alpha_blend) { 297 + return XR_SUCCESS; 298 + } 299 + 300 + const XrCompositionLayerAlphaBlendFB *alphaBlend = OXR_GET_INPUT_FROM_CHAIN( 301 + layer, (XrStructureType)XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB, XrCompositionLayerAlphaBlendFB); 302 + 303 + if (alphaBlend != NULL) { 304 + if (!u_verify_blend_factor_valid(alphaBlend->srcFactorColor)) { 305 + return oxr_error( 306 + log, XR_ERROR_VALIDATION_FAILURE, 307 + "(frameEndInfo->layers[%u]->pNext->srcFactorColor == 0x%08x) unknown blend factor", 308 + layer_index, alphaBlend->srcFactorColor); 309 + } 310 + if (!u_verify_blend_factor_valid(alphaBlend->dstFactorColor)) { 311 + return oxr_error(log, XR_ERROR_VALIDATION_FAILURE, 312 + "(frameEndInfo->layers[%u]->dstFactorColor == 0x%08x) unknown blend factor", 313 + layer_index, alphaBlend->dstFactorColor); 314 + } 315 + if (!u_verify_blend_factor_valid(alphaBlend->srcFactorAlpha)) { 316 + return oxr_error(log, XR_ERROR_VALIDATION_FAILURE, 317 + "(frameEndInfo->layers[%u]->srcFactorAlpha == 0x%08x) unknown blend factor", 318 + layer_index, alphaBlend->srcFactorAlpha); 319 + } 320 + if (!u_verify_blend_factor_valid(alphaBlend->dstFactorAlpha)) { 321 + return oxr_error(log, XR_ERROR_VALIDATION_FAILURE, 322 + "(frameEndInfo->layers[%u]->dstFactorAlpha == 0x%08x) unknown blend factor", 323 + layer_index, alphaBlend->dstFactorAlpha); 324 + } 325 + } 326 + #else 327 + // Extension isn't enabled, always pass. 328 + return XR_SUCCESS; 329 + #endif 330 + } 331 + 332 + static XrResult 253 333 verify_space(struct oxr_logger *log, uint32_t layer_index, XrSpace space) 254 334 { 255 335 if (space == XR_NULL_HANDLE) { ··· 263 343 } 264 344 265 345 static XrResult 266 - verify_quad_layer(struct xrt_compositor *xc, 346 + verify_quad_layer(struct oxr_session *sess, 347 + struct xrt_compositor *xc, 267 348 struct oxr_logger *log, 268 349 uint32_t layer_index, 269 350 XrCompositionLayerQuad *quad, ··· 278 359 } 279 360 280 361 XrResult ret = verify_space(log, layer_index, quad->space); 362 + if (ret != XR_SUCCESS) { 363 + return ret; 364 + } 365 + 366 + ret = verify_blend_factors(log, sess, layer_index, (XrCompositionLayerBaseHeader *)quad); 281 367 if (ret != XR_SUCCESS) { 282 368 return ret; 283 369 } ··· 435 521 } 436 522 437 523 static XrResult 438 - verify_projection_layer(struct xrt_compositor *xc, 524 + verify_projection_layer(struct oxr_session *sess, 525 + struct xrt_compositor *xc, 439 526 struct oxr_logger *log, 440 527 uint32_t layer_index, 441 528 XrCompositionLayerProjection *proj, ··· 447 534 return ret; 448 535 } 449 536 537 + ret = verify_blend_factors(log, sess, layer_index, (XrCompositionLayerBaseHeader *)proj); 538 + if (ret != XR_SUCCESS) { 539 + return ret; 540 + } 541 + 450 542 if (proj->viewCount != 2) { 451 543 return oxr_error(log, XR_ERROR_VALIDATION_FAILURE, 452 544 "(frameEndInfo->layers[%u]->viewCount == %u) must be 2 for projection layers and the " ··· 562 654 } 563 655 564 656 static XrResult 565 - verify_cube_layer(struct xrt_compositor *xc, 657 + verify_cube_layer(struct oxr_session *sess, 658 + struct xrt_compositor *xc, 566 659 struct oxr_logger *log, 567 660 uint32_t layer_index, 568 661 const XrCompositionLayerCubeKHR *cube, ··· 583 676 } 584 677 585 678 XrResult ret = verify_space(log, layer_index, cube->space); 679 + if (ret != XR_SUCCESS) { 680 + return ret; 681 + } 682 + 683 + ret = verify_blend_factors(log, sess, layer_index, (XrCompositionLayerBaseHeader *)cube); 586 684 if (ret != XR_SUCCESS) { 587 685 return ret; 588 686 } ··· 624 722 } 625 723 626 724 static XrResult 627 - verify_cylinder_layer(struct xrt_compositor *xc, 725 + verify_cylinder_layer(struct oxr_session *sess, 726 + struct xrt_compositor *xc, 628 727 struct oxr_logger *log, 629 728 uint32_t layer_index, 630 729 const XrCompositionLayerCylinderKHR *cylinder, ··· 649 748 return ret; 650 749 } 651 750 751 + ret = verify_blend_factors(log, sess, layer_index, (XrCompositionLayerBaseHeader *)cylinder); 752 + if (ret != XR_SUCCESS) { 753 + return ret; 754 + } 755 + 652 756 if (!math_quat_validate_within_1_percent((struct xrt_quat *)&cylinder->pose.orientation)) { 653 757 const XrQuaternionf *q = &cylinder->pose.orientation; 654 758 return oxr_error(log, XR_ERROR_POSE_INVALID, ··· 728 832 } 729 833 730 834 static XrResult 731 - verify_equirect1_layer(struct xrt_compositor *xc, 835 + verify_equirect1_layer(struct oxr_session *sess, 836 + struct xrt_compositor *xc, 732 837 struct oxr_logger *log, 733 838 uint32_t layer_index, 734 839 const XrCompositionLayerEquirectKHR *equirect, ··· 749 854 } 750 855 751 856 XrResult ret = verify_space(log, layer_index, equirect->space); 857 + if (ret != XR_SUCCESS) { 858 + return ret; 859 + } 860 + 861 + ret = verify_blend_factors(log, sess, layer_index, (XrCompositionLayerBaseHeader *)equirect); 752 862 if (ret != XR_SUCCESS) { 753 863 return ret; 754 864 } ··· 820 930 } 821 931 822 932 static XrResult 823 - verify_equirect2_layer(struct xrt_compositor *xc, 933 + verify_equirect2_layer(struct oxr_session *sess, 934 + struct xrt_compositor *xc, 824 935 struct oxr_logger *log, 825 936 uint32_t layer_index, 826 937 const XrCompositionLayerEquirect2KHR *equirect, ··· 840 951 } 841 952 842 953 XrResult ret = verify_space(log, layer_index, equirect->space); 954 + if (ret != XR_SUCCESS) { 955 + return ret; 956 + } 957 + 958 + ret = verify_blend_factors(log, sess, layer_index, (XrCompositionLayerBaseHeader *)equirect); 843 959 if (ret != XR_SUCCESS) { 844 960 return ret; 845 961 } ··· 1030 1146 fill_in_sub_image(sc, &quad->subImage, &data.quad.sub); 1031 1147 fill_in_color_scale_bias(sess, (XrCompositionLayerBaseHeader *)quad, &data); 1032 1148 fill_in_y_flip(sess, (XrCompositionLayerBaseHeader *)quad, &data); 1149 + fill_in_blend_factors(sess, (XrCompositionLayerBaseHeader *)quad, &data); 1033 1150 fill_in_layer_settings(sess, (XrCompositionLayerBaseHeader *)quad, &data); 1034 1151 1035 1152 xrt_result_t xret = xrt_comp_layer_quad(xc, head, sc->swapchain, &data); ··· 1087 1204 fill_in_sub_image(scs[1], &proj->views[1].subImage, &data.stereo.r.sub); 1088 1205 fill_in_color_scale_bias(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1089 1206 fill_in_y_flip(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1090 - 1207 + fill_in_blend_factors(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1091 1208 fill_in_layer_settings(sess, (XrCompositionLayerBaseHeader *)proj, &data); 1092 1209 1093 1210 #ifdef OXR_HAVE_KHR_composition_layer_depth ··· 1184 1301 data.cube.sub.array_index = cube->imageArrayIndex; 1185 1302 fill_in_color_scale_bias(sess, (XrCompositionLayerBaseHeader *)cube, &data); 1186 1303 fill_in_y_flip(sess, (XrCompositionLayerBaseHeader *)cube, &data); 1304 + fill_in_blend_factors(sess, (XrCompositionLayerBaseHeader *)cube, &data); 1187 1305 1188 1306 struct xrt_pose pose = { 1189 1307 .orientation = ··· 1248 1366 fill_in_sub_image(sc, &cylinder->subImage, &data.cylinder.sub); 1249 1367 fill_in_color_scale_bias(sess, (XrCompositionLayerBaseHeader *)cylinder, &data); 1250 1368 fill_in_y_flip(sess, (XrCompositionLayerBaseHeader *)cylinder, &data); 1369 + fill_in_blend_factors(sess, (XrCompositionLayerBaseHeader *)cylinder, &data); 1251 1370 fill_in_layer_settings(sess, (XrCompositionLayerBaseHeader *)cylinder, &data); 1252 1371 1253 1372 xrt_result_t xret = xrt_comp_layer_cylinder(xc, head, sc->swapchain, &data); ··· 1294 1413 fill_in_sub_image(sc, &equirect->subImage, &data.equirect1.sub); 1295 1414 fill_in_color_scale_bias(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1296 1415 fill_in_y_flip(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1416 + fill_in_blend_factors(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1297 1417 fill_in_layer_settings(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1298 1418 1299 1419 struct xrt_vec2 *scale = (struct xrt_vec2 *)&equirect->scale; ··· 1358 1478 fill_in_sub_image(sc, &equirect->subImage, &data.equirect2.sub); 1359 1479 fill_in_color_scale_bias(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1360 1480 fill_in_y_flip(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1481 + fill_in_blend_factors(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1361 1482 fill_in_layer_settings(sess, (XrCompositionLayerBaseHeader *)equirect, &data); 1362 1483 1363 1484 xrt_result_t xret = xrt_comp_layer_equirect2(xc, head, sc->swapchain, &data); ··· 1472 1593 1473 1594 switch (layer->type) { 1474 1595 case XR_TYPE_COMPOSITION_LAYER_PROJECTION: 1475 - res = verify_projection_layer(xc, log, i, (XrCompositionLayerProjection *)layer, xdev, 1596 + res = verify_projection_layer(sess, xc, log, i, (XrCompositionLayerProjection *)layer, xdev, 1476 1597 frameEndInfo->displayTime); 1477 1598 break; 1478 1599 case XR_TYPE_COMPOSITION_LAYER_QUAD: 1479 - res = verify_quad_layer(xc, log, i, (XrCompositionLayerQuad *)layer, xdev, 1600 + res = verify_quad_layer(sess, xc, log, i, (XrCompositionLayerQuad *)layer, xdev, 1480 1601 frameEndInfo->displayTime); 1481 1602 break; 1482 1603 case XR_TYPE_COMPOSITION_LAYER_CUBE_KHR: 1483 - res = verify_cube_layer(xc, log, i, (XrCompositionLayerCubeKHR *)layer, xdev, 1604 + res = verify_cube_layer(sess, xc, log, i, (XrCompositionLayerCubeKHR *)layer, xdev, 1484 1605 frameEndInfo->displayTime); 1485 1606 break; 1486 1607 case XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR: 1487 - res = verify_cylinder_layer(xc, log, i, (XrCompositionLayerCylinderKHR *)layer, xdev, 1608 + res = verify_cylinder_layer(sess, xc, log, i, (XrCompositionLayerCylinderKHR *)layer, xdev, 1488 1609 frameEndInfo->displayTime); 1489 1610 break; 1490 1611 case XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR: 1491 - res = verify_equirect1_layer(xc, log, i, (XrCompositionLayerEquirectKHR *)layer, xdev, 1612 + res = verify_equirect1_layer(sess, xc, log, i, (XrCompositionLayerEquirectKHR *)layer, xdev, 1492 1613 frameEndInfo->displayTime); 1493 1614 break; 1494 1615 case XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR: 1495 - res = verify_equirect2_layer(xc, log, i, (XrCompositionLayerEquirect2KHR *)layer, xdev, 1616 + res = verify_equirect2_layer(sess, xc, log, i, (XrCompositionLayerEquirect2KHR *)layer, xdev, 1496 1617 frameEndInfo->displayTime); 1497 1618 break; 1498 1619 default: