+5 -2

src/xrt/compositor/main/comp_compositor.c

··· 1132 1132 struct xrt_system_compositor_info sys_info_storage = {0}; 1133 1133 struct xrt_system_compositor_info *sys_info = &sys_info_storage; 1134 1134 1135 1135 - // Required by OpenXR spec. 1136 1136 - sys_info->max_layers = XRT_MAX_LAYERS; 1135 1135 + // Required by OpenXR spec (minimum 16). 1136 1136 + sys_info->max_layers = render_max_layers_capable( // 1137 1137 + get_vk(c), // 1138 1138 + c->settings.use_compute, // 1139 1139 + XRT_MAX_LAYERS); // 1137 1140 sys_info->compositor_vk_deviceUUID = c->settings.selected_gpu_deviceUUID; 1138 1141 sys_info->client_vk_deviceUUID = c->settings.client_gpu_deviceUUID; 1139 1142 sys_info->client_d3d_deviceLUID = c->settings.client_gpu_deviceLUID;

+7 -1

src/xrt/compositor/null/null_compositor.c

··· 268 268 { 269 269 struct xrt_system_compositor_info *sys_info = &c->sys_info; 270 270 271 271 - // Required by OpenXR spec. 271 271 + /* 272 272 + * Required by OpenXR spec (minimum 16). 273 273 + * 274 274 + * NOTE: When using Vulkan compositor components (c/render, c/util), 275 275 + * call render_max_layers_capable() to clamp this value based on 276 276 + * actual device limits. 277 277 + */ 272 278 sys_info->max_layers = XRT_MAX_LAYERS; 273 279 274 280 uint32_t view_count = xdev->hmd->view_count;

+18

src/xrt/compositor/render/render_interface.h

··· 93 93 //! The binding that the shared layer fragment shader has its source on. 94 94 #define RENDER_BINDING_LAYER_SHARED_SRC 1 95 95 96 96 + /*! 97 97 + * The maximum number samplers per view that can be used by the compute shader 98 98 + * for layer composition (layer.comp) 99 99 + */ 100 100 + #define RENDER_CS_MAX_SAMPLERS_PER_VIEW 2 96 101 97 102 /* 98 103 * 99 104 * Util functions. 100 105 * 101 106 */ 107 107 + 108 108 + /*! 109 109 + * Determines the maximum number of compositor layers supported based on Vulkan 110 110 + * device limits and the composition path being used. 111 111 + * 112 112 + * @param vk Vulkan bundle containing device properties 113 113 + * @param use_compute True if using compute pipeline path, false for graphics 114 114 + * @param desired_max_layers Maximum layers requested by the compositor 115 115 + * @return Actual maximum layers supported, clamped by device limits (minimum 16) 116 116 + * 117 117 + */ 118 118 + uint32_t 119 119 + render_max_layers_capable(const struct vk_bundle *vk, bool use_compute, uint32_t desired_max_layers); 102 120 103 121 /*! 104 122 * Create a simplified projection matrix for timewarp.

+49

src/xrt/compositor/render/render_util.c

··· 87 87 * 88 88 */ 89 89 90 90 + uint32_t 91 91 + render_max_layers_capable(const struct vk_bundle *vk, bool use_compute, uint32_t desired_max_layers) 92 92 + { 93 93 + /*! 94 94 + * Graphics pipeline: 95 95 + * 96 96 + * This path has no relevant Vulkan device limits that would 97 97 + * constrain the maximum number of layers (each layer uses a single descriptor 98 98 + * set bound individually per draw). 99 99 + */ 100 100 + if (!use_compute) { 101 101 + // The min required by OpenXR spec is 16. 102 102 + return MAX(desired_max_layers, 16); 103 103 + } 104 104 + 105 105 + /*! 106 106 + * Compute pipeline: 107 107 + * 108 108 + * Clamp max layers based on compute pipeline descriptor limits. 109 109 + * 110 110 + * The compute path uses an array of combined image samplers, with 111 111 + * @ref samplers_per_layer samplers needed per layer. We check both the 112 112 + * per-stage sampler and sampled image limits, then calculate the 113 113 + * maximum number of complete layers that fit within those limits. 114 114 + */ 115 115 + uint32_t desired_image_sampler_count = desired_max_layers * RENDER_CS_MAX_SAMPLERS_PER_VIEW; 116 116 + 117 117 + const uint32_t max_sizes[] = { 118 118 + vk->limits.max_per_stage_descriptor_samplers, 119 119 + vk->limits.max_per_stage_descriptor_sampled_images, 120 120 + }; 121 121 + for (uint32_t i = 0; i < ARRAY_SIZE(max_sizes); ++i) { 122 122 + desired_image_sampler_count = MIN(desired_image_sampler_count, max_sizes[i]); 123 123 + } 124 124 + 125 125 + const uint32_t calculated_max_layers = desired_image_sampler_count / RENDER_CS_MAX_SAMPLERS_PER_VIEW; 126 126 + 127 127 + if (calculated_max_layers < 16) { 128 128 + VK_WARN(vk, 129 129 + "Device supports only %u compositor layers due to Vulkan limits. " 130 130 + "which is below Vulkan minimum of 16. " 131 131 + "This may indicate a driver bug. Attempting 16 anyway.", 132 132 + calculated_max_layers); 133 133 + } 134 134 + 135 135 + // The min required by OpenXR spec is 16. 136 136 + return MAX(calculated_max_layers, 16); 137 137 + } 138 138 + 90 139 void 91 140 render_calc_time_warp_matrix(const struct xrt_pose *src_pose, 92 141 const struct xrt_fov *src_fov,

+7 -1

src/xrt/targets/sdl_test/sdl_compositor.c

··· 256 256 { 257 257 struct xrt_system_compositor_info *sys_info = &c->sys_info; 258 258 259 259 - // Required by OpenXR spec. 259 259 + /* 260 260 + * Required by OpenXR spec (minimum 16). 261 261 + * 262 262 + * NOTE: When using Vulkan compositor components (c/render, c/util), 263 263 + * call render_max_layers_capable() to clamp this value based on 264 264 + * actual device limits. 265 265 + */ 260 266 sys_info->max_layers = XRT_MAX_LAYERS; 261 267 262 268 // UUIDs and LUID already set in vk init.