The open source OpenXR runtime
st/oxr: Implement XR_KHR_visibility_mask
authored by
Simon Zeni
and committed by
Jakob Bornecrantz
96be7675
c1ce722d
+122
-5
+1
scripts/generate_oxr_ext_support.py
+1
scripts/generate_oxr_ext_support.py
···
49
49
['XR_KHR_opengl_enable', 'XR_USE_GRAPHICS_API_OPENGL'],
50
50
['XR_KHR_opengl_es_enable', 'XR_USE_GRAPHICS_API_OPENGL_ES'],
51
51
['XR_KHR_swapchain_usage_input_attachment_bit'],
52
+
['XR_KHR_visibility_mask'],
52
53
['XR_KHR_vulkan_enable', 'XR_USE_GRAPHICS_API_VULKAN'],
53
54
['XR_KHR_vulkan_enable2', 'XR_USE_GRAPHICS_API_VULKAN'],
54
55
['XR_KHR_win32_convert_performance_counter_time', 'XR_USE_PLATFORM_WIN32'],
+4
src/xrt/state_trackers/oxr/oxr_api_negotiate.c
+4
src/xrt/state_trackers/oxr/oxr_api_negotiate.c
···
264
264
ENTRY_IF_EXT(xrGetOpenGLESGraphicsRequirementsKHR, KHR_opengl_es_enable);
265
265
#endif // OXR_HAVE_KHR_opengl_es_enable
266
266
267
+
#ifdef OXR_HAVE_KHR_visibility_mask
268
+
ENTRY_IF_EXT(xrGetVisibilityMaskKHR, KHR_visibility_mask);
269
+
#endif // OXR_HAVE_KHR_visibility_mask
270
+
267
271
#ifdef OXR_HAVE_KHR_vulkan_enable
268
272
ENTRY_IF_EXT(xrGetVulkanInstanceExtensionsKHR, KHR_vulkan_enable);
269
273
ENTRY_IF_EXT(xrGetVulkanDeviceExtensionsKHR, KHR_vulkan_enable);
+33
-5
src/xrt/state_trackers/oxr/oxr_api_session.c
+33
-5
src/xrt/state_trackers/oxr/oxr_api_session.c
···
258
258
*/
259
259
260
260
#ifdef XR_KHR_visibility_mask
261
-
262
261
XRAPI_ATTR XrResult XRAPI_CALL
263
262
oxr_xrGetVisibilityMaskKHR(XrSession session,
264
263
XrViewConfigurationType viewConfigurationType,
···
268
267
{
269
268
OXR_TRACE_MARKER();
270
269
271
-
struct oxr_session *sess;
270
+
struct oxr_session *sess = NULL;
272
271
struct oxr_logger log;
273
272
OXR_VERIFY_SESSION_AND_INIT_LOG(&log, session, sess, "xrGetVisibilityMaskKHR");
274
273
OXR_VERIFY_SESSION_NOT_LOST(&log, sess);
275
274
276
-
return oxr_error(&log, XR_ERROR_HANDLE_INVALID, "Not implemented");
277
-
}
275
+
OXR_VERIFY_EXTENSION(&log, sess->sys->inst, KHR_visibility_mask);
276
+
277
+
visibilityMask->vertexCountOutput = 0;
278
+
visibilityMask->indexCountOutput = 0;
279
+
280
+
OXR_VERIFY_VIEW_CONFIG_TYPE(&log, sess->sys->inst, viewConfigurationType);
281
+
if (viewConfigurationType != sess->sys->view_config_type) {
282
+
return oxr_error(&log, XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED,
283
+
"(viewConfigurationType == 0x%08x) unsupported view configuration type",
284
+
viewConfigurationType);
285
+
}
278
286
279
-
#endif
287
+
OXR_VERIFY_VIEW_INDEX(&log, viewIndex);
280
288
289
+
if (visibilityMaskType != XR_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR &&
290
+
visibilityMaskType != XR_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR &&
291
+
visibilityMaskType != XR_VISIBILITY_MASK_TYPE_LINE_LOOP_KHR) {
292
+
return oxr_error(&log, XR_ERROR_VALIDATION_FAILURE, "(visibilityMaskType == %d) is invalid",
293
+
visibilityMaskType);
294
+
}
295
+
296
+
OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, visibilityMask, XR_TYPE_VISIBILITY_MASK_KHR);
297
+
298
+
if (visibilityMask->vertexCapacityInput != 0) {
299
+
OXR_VERIFY_ARG_NOT_NULL(&log, visibilityMask->vertices);
300
+
}
301
+
302
+
if (visibilityMask->indexCapacityInput != 0) {
303
+
OXR_VERIFY_ARG_NOT_NULL(&log, visibilityMask->indices);
304
+
}
305
+
306
+
return oxr_session_get_visibility_mask(&log, sess, visibilityMaskType, visibilityMask);
307
+
}
308
+
#endif // OXR_HAVE_KHR_visibility_mask
281
309
282
310
/*
283
311
*
+12
src/xrt/state_trackers/oxr/oxr_extension_support.h
+12
src/xrt/state_trackers/oxr/oxr_extension_support.h
···
202
202
203
203
204
204
/*
205
+
* XR_KHR_visibility_mask
206
+
*/
207
+
#if defined(XR_KHR_visibility_mask)
208
+
#define OXR_HAVE_KHR_visibility_mask
209
+
#define OXR_EXTENSION_SUPPORT_KHR_visibility_mask(_) _(KHR_visibility_mask, KHR_VISIBILITY_MASK)
210
+
#else
211
+
#define OXR_EXTENSION_SUPPORT_KHR_visibility_mask(_)
212
+
#endif
213
+
214
+
215
+
/*
205
216
* XR_KHR_vulkan_enable
206
217
*/
207
218
#if defined(XR_KHR_vulkan_enable) && defined(XR_USE_GRAPHICS_API_VULKAN)
···
534
545
OXR_EXTENSION_SUPPORT_KHR_opengl_enable(_) \
535
546
OXR_EXTENSION_SUPPORT_KHR_opengl_es_enable(_) \
536
547
OXR_EXTENSION_SUPPORT_KHR_swapchain_usage_input_attachment_bit(_) \
548
+
OXR_EXTENSION_SUPPORT_KHR_visibility_mask(_) \
537
549
OXR_EXTENSION_SUPPORT_KHR_vulkan_enable(_) \
538
550
OXR_EXTENSION_SUPPORT_KHR_vulkan_enable2(_) \
539
551
OXR_EXTENSION_SUPPORT_KHR_win32_convert_performance_counter_time(_) \
+4
src/xrt/state_trackers/oxr/oxr_instance.c
+4
src/xrt/state_trackers/oxr/oxr_instance.c
···
68
68
u_hashset_destroy(&inst->action_sets.name_store);
69
69
u_hashset_destroy(&inst->action_sets.loc_store);
70
70
71
+
// Free the mask here, no system destroy yet.
72
+
free(inst->system.visibility_mask);
73
+
inst->system.visibility_mask = NULL;
74
+
71
75
xrt_space_overseer_destroy(&inst->system.xso);
72
76
os_mutex_destroy(&inst->system.sync_actions_mutex);
73
77
xrt_system_devices_destroy(&inst->system.xsysd);
+10
src/xrt/state_trackers/oxr/oxr_objects.h
+10
src/xrt/state_trackers/oxr/oxr_objects.h
···
761
761
uint32_t threadId);
762
762
#endif // OXR_HAVE_KHR_android_thread_settings
763
763
764
+
#ifdef OXR_HAVE_KHR_visibility_mask
765
+
XrResult
766
+
oxr_session_get_visibility_mask(struct oxr_logger *log,
767
+
struct oxr_session *session,
768
+
XrVisibilityMaskTypeKHR visibilityMaskType,
769
+
XrVisibilityMaskKHR *visibilityMask);
770
+
#endif // OXR_HAVE_KHR_visibility_mask
771
+
764
772
/*
765
773
*
766
774
* oxr_space.c
···
1282
1290
//! Cache of the last known system roles, see @xrt_system_roles::generation_id
1283
1291
struct xrt_system_roles dynamic_roles_cache;
1284
1292
struct os_mutex sync_actions_mutex;
1293
+
1294
+
struct xrt_visibility_mask *visibility_mask;
1285
1295
1286
1296
#ifdef XR_USE_GRAPHICS_API_VULKAN
1287
1297
//! The instance/device we create when vulkan_enable2 is used
+58
src/xrt/state_trackers/oxr/oxr_session.c
+58
src/xrt/state_trackers/oxr/oxr_session.c
···
1159
1159
return XR_SUCCESS;
1160
1160
}
1161
1161
#endif // OXR_HAVE_KHR_android_thread_settings
1162
+
1163
+
#ifdef OXR_HAVE_KHR_visibility_mask
1164
+
1165
+
static enum xrt_visibility_mask_type
1166
+
convert_mask_type(XrVisibilityMaskTypeKHR type)
1167
+
{
1168
+
switch (type) {
1169
+
case XR_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR: return XRT_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH;
1170
+
case XR_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR: return XRT_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH;
1171
+
case XR_VISIBILITY_MASK_TYPE_LINE_LOOP_KHR: return XRT_VISIBILITY_MASK_TYPE_LINE_LOOP;
1172
+
default: return (enum xrt_visibility_mask_type)0;
1173
+
}
1174
+
}
1175
+
1176
+
XrResult
1177
+
oxr_session_get_visibility_mask(struct oxr_logger *log,
1178
+
struct oxr_session *sess,
1179
+
XrVisibilityMaskTypeKHR visibilityMaskType,
1180
+
XrVisibilityMaskKHR *visibilityMask)
1181
+
{
1182
+
struct oxr_system *sys = sess->sys;
1183
+
struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, head);
1184
+
enum xrt_visibility_mask_type type = convert_mask_type(visibilityMaskType);
1185
+
1186
+
if (sys->visibility_mask && sys->visibility_mask->type != type) {
1187
+
free(sys->visibility_mask);
1188
+
sys->visibility_mask = NULL;
1189
+
}
1190
+
1191
+
if (sys->visibility_mask == NULL) {
1192
+
xdev->get_visibility_mask(xdev, type, &sys->visibility_mask);
1193
+
}
1194
+
1195
+
struct xrt_visibility_mask *mask = sys->visibility_mask;
1196
+
1197
+
visibilityMask->vertexCountOutput = mask->vertex_count;
1198
+
visibilityMask->indexCountOutput = mask->index_count;
1199
+
1200
+
if (visibilityMask->vertexCapacityInput == 0 || visibilityMask->indexCapacityInput == 0) {
1201
+
return XR_SUCCESS;
1202
+
}
1203
+
1204
+
if (visibilityMask->vertexCapacityInput < mask->vertex_count) {
1205
+
return oxr_error(log, XR_ERROR_SIZE_INSUFFICIENT, "vertexCapacityInput is %u, need %u",
1206
+
visibilityMask->vertexCapacityInput, mask->vertex_count);
1207
+
} else if (visibilityMask->indexCapacityInput < mask->index_count) {
1208
+
return oxr_error(log, XR_ERROR_SIZE_INSUFFICIENT, "indexCapacityInput is %u, need %u",
1209
+
visibilityMask->indexCapacityInput, mask->index_count);
1210
+
}
1211
+
1212
+
memcpy(visibilityMask->vertices, xrt_visibility_mask_get_vertices(mask),
1213
+
sizeof(struct xrt_vec2) * mask->vertex_count);
1214
+
memcpy(visibilityMask->indices, xrt_visibility_mask_get_indices(mask), sizeof(uint32_t) * mask->index_count);
1215
+
1216
+
return XR_SUCCESS;
1217
+
}
1218
+
1219
+
#endif // OXR_HAVE_KHR_visibility_mask