xrt: Improve doxygen documentation.

doc/Doxyfile.in

···
 
 WARN_IF_UNDOCUMENTED   = @DOXYGEN_WARN_UNDOCUMENTED@
 EXTRACT_ALL            = @DOXYGEN_EXTRACT_ALL@
+HIDE_UNDOC_RELATIONS   = NO
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
 # path mentioned in the documentation of a class, which tells the reader which
···
 # and usage relations if the target is undocumented or is not a class.
 # The default value is: YES.
 
-HIDE_UNDOC_RELATIONS   = YES
+# HIDE_UNDOC_RELATIONS   = YES
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz (see:

doc/changes/xrt/mr.365.md

···
+Improve Doxygen documentation of interfaces. Now the inheritance structure and implementation of interfaces is shown in the docs, and helper functions that call through function pointers are listed as "member functions", to help developers understand the internal structure of Monado better.

src/xrt/auxiliary/os/os_ble.h

···
 
 
 /*!
+ * @interface os_ble_device
  * Representing a single ble notify attribute on a device.
  *
  * @ingroup aux_os

src/xrt/auxiliary/os/os_ble_dbus.c

···
  *
  */
 
+/*!
+ * An implementation of @ref os_ble_device using a DBus connection to BlueZ.
+ * @implements os_ble_device
+ */
 struct ble_notify
 {
 	struct os_ble_device base;

src/xrt/auxiliary/os/os_hid.h

···
 
 
 /*!
+ * @interface os_hid_device
+ *
  * Representing a single hid interface on a device.
  */
 struct os_hid_device
···
  *
  * If milliseconds are negative, this call blocks indefinitely, 0 polls,
  * and positive will block for that amount of milliseconds.
+ *
+ * @public @memberof os_hid_device
  */
 static inline int
 os_hid_read(struct os_hid_device *hid_dev,
···
 
 /*!
  * Write an output report to the given device.
+ *
+ * @public @memberof os_hid_device
  */
 static inline int
 os_hid_write(struct os_hid_device *hid_dev, const uint8_t *data, size_t size)
···
  *
  * If the device doesn't have more than one feature report, just request
  * report 0.
+ *
+ * @public @memberof os_hid_device
  */
 static inline int
 os_hid_get_feature(struct os_hid_device *hid_dev,
···
 
 /*!
  * Get a feature report with a timeout.
+ *
+ * @public @memberof os_hid_device
  */
 static inline int
 os_hid_get_feature_timeout(struct os_hid_device *hid_dev,
···
  *
  * The first byte of the buffer is the report number, to be followed by
  * the data of the report.
+ *
+ * @public @memberof os_hid_device
  */
 static inline int
 os_hid_set_feature(struct os_hid_device *hid_dev,
···
 
 /*!
  * Close and free the given device.
+ *
+ * @public @memberof os_hid_device
  */
 static inline void
 os_hid_destroy(struct os_hid_device *hid_dev)
···
 #ifdef XRT_OS_LINUX
 /*!
  * Open the given path as a hidraw device.
+ *
+ * @public @memberof hid_hidraw
+ * @relatesalso os_hid_device
  */
 int
 os_hid_open_hidraw(const char *path, struct os_hid_device **out_hid);

src/xrt/auxiliary/os/os_hid_hidraw.c

···
 
 #include <stdio.h>
 
+/*!
+ * @implements os_hid_device
+ */
 struct hid_hidraw
 {
 	struct os_hid_device base;

src/xrt/auxiliary/tracking/t_debug_hsv_filter.cpp

···
 #define HSV2_WIN "HSV Channel #3 (Blue)"
 #define HSV3_WIN "HSV Channel #4 (White)"
 
+/*!
+ * An @ref xrt_frame_sink that can be used to debug the behavior of
+ * @ref t_hsv_filter.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 class DebugHSVFilter
 {
 public:

src/xrt/auxiliary/tracking/t_debug_hsv_picker.cpp

···
 #define max(a, b) (a > b ? a : b)
 #define min(a, b) (a < b ? a : b)
 
+/*!
+ * An @ref xrt_frame_sink that can be used to select HSV thresholds
+ * interactively.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 class DebugHSVPicker
 {
 public:

src/xrt/auxiliary/tracking/t_debug_hsv_viewer.cpp

···
 
 #define HSV_WIN "HSV Filter Tester"
 
+/*!
+ * An @ref xrt_frame_sink related to debug viewing of HSV.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 class DebugHSVViewer
 {
 public:

src/xrt/auxiliary/tracking/t_hsv_filter.c

···
 
 #define NUM_CHANNELS 4
 
+/*!
+ * An @ref xrt_frame_sink that splits the input based on hue.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct t_hsv_filter
 {
 	struct xrt_frame_sink base;

src/xrt/auxiliary/tracking/t_tracker_psmv.cpp

···
 
 /*!
  * Single camera.
+ *
+ * @see TrackerPSMV
  */
 struct View
 {
···
 	}
 };
 
+/*!
+ * The core object of the PS Move tracking setup.
+ *
+ * @implements xrt_tracked_psmv
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct TrackerPSMV
 {
 	struct xrt_tracked_psmv base = {};

src/xrt/auxiliary/tracking/t_tracking.h

···
 
 /*!
  * Allocates a new stereo calibration data, unreferences the old @p calib.
+ *
+ * @public @memberof t_stereo_camera_calibration
  */
 void
 t_stereo_camera_calibration_alloc(struct t_stereo_camera_calibration **calib);
 
 /*!
  * Only to be called by @p t_stereo_camera_calibration_reference.
+ *
+ * @private @memberof t_stereo_camera_calibration
  */
 void
 t_stereo_camera_calibration_destroy(struct t_stereo_camera_calibration *c);
···
  *                @p dst points to will be set to @p src.
  * @param[in] src Object to be have it's refcount increased @p dst is set to
  *                this.
+ *
+ * @relates t_stereo_camera_calibration
  */
 static inline void
 t_stereo_camera_calibration_reference(struct t_stereo_camera_calibration **dst,
···
 	uint8_t v_min;
 };
 
+/*!
+ * Parameters for constructing an HSV filter.
+ * @relates t_hsv_filter
+ */
 struct t_hsv_filter_params
 {
 	struct t_hsv_filter_color color[3];
···
 	return t->v[y / T_HSV_STEP][u / T_HSV_STEP][v / T_HSV_STEP];
 }
 
+/*!
+ * Construct an HSV filter sink.
+ * @public @memberof t_hsv_filter
+ *
+ * @relates xrt_frame_context
+ */
 int
 t_hsv_filter_create(struct xrt_frame_context *xfctx,
                     struct t_hsv_filter_params *params,
···
  *
  */
 
+/*!
+ * @public @memberof xrt_tracked_psmv
+ */
 int
 t_psmv_start(struct xrt_tracked_psmv *xtmv);
 
+/*!
+ * @public @memberof xrt_tracked_psmv
+ */
 int
 t_psmv_create(struct xrt_frame_context *xfctx,
               struct xrt_colour_rgb_f32 *rgb,
···
               struct xrt_tracked_psmv **out_xtmv,
               struct xrt_frame_sink **out_sink);
 
+/*!
+ * @public @memberof xrt_tracked_psvr
+ */
 int
 t_psvr_start(struct xrt_tracked_psvr *xtvr);
 
+/*!
+ * @public @memberof xrt_tracked_psvr
+ */
 int
 t_psvr_create(struct xrt_frame_context *xfctx,
               struct t_stereo_camera_calibration *data,
···
 
 /*!
  * Sets the calibration parameters to the their default values.
+ * @public @memberof t_calibration_params
  */
 static inline void
 t_calibration_params_default(struct t_calibration_params *p)
···
  * retained, and pointed-to struct modified.
  * @param gui Frame sink
  * @param out_sink Output: created frame sink.
+ *
+ * @relates xrt_frame_context
  */
 int
 t_calibration_stereo_create(struct xrt_frame_context *xfctx,
···
  *
  */
 
+/*!
+ * @relates xrt_frame_context
+ */
 int
 t_convert_yuv_or_yuyv_create(struct xrt_frame_sink *next,
                              struct xrt_frame_sink **out_sink);
 
 
 
+/*!
+ * @relates xrt_frame_context
+ */
 int
 t_debug_hsv_picker_create(struct xrt_frame_context *xfctx,
                           struct xrt_frame_sink *passthrough,
                           struct xrt_frame_sink **out_sink);
 
+/*!
+ * @relates xrt_frame_context
+ */
 int
 t_debug_hsv_viewer_create(struct xrt_frame_context *xfctx,
                           struct xrt_frame_sink *passthrough,
                           struct xrt_frame_sink **out_sink);
 
+/*!
+ * @relates xrt_frame_context
+ */
 int
 t_debug_hsv_filter_create(struct xrt_frame_context *xfctx,
                           struct xrt_frame_sink *passthrough,

src/xrt/auxiliary/util/u_distortion_mesh.c

···
 #define div_scalar m_vec2_div_scalar
 #define len m_vec2_len
 
-
+/*!
+ * @implements u_uv_generator
+ */
 struct panotools_state
 {
 	struct u_uv_generator base;

src/xrt/auxiliary/util/u_distortion_mesh.h

···
 };
 
 /*!
- * Generator struct for building meshes, can be implemented by drivers for
+ * @interface u_uv_generator
+ *
+ * Generator interface for building meshes, can be implemented by drivers for
  * special meshes.
  *
  * @ingroup aux_util
···
  * Given a @ref u_uv_generator generates num_views meshes, populates target.
  *
  * @ingroup aux_util
+ * @public @memberof u_uv_generator
+ * @relatesalso xrt_hmd_parts
  */
 void
 u_distortion_mesh_from_gen(struct u_uv_generator *,
···
  * values into it. This probably isn't the function you want.
  *
  * @ingroup aux_util
+ * @see u_distortion_mesh_from_panotools
  */
 void
 u_distortion_mesh_generator_from_panotools(
···
  * This is probably the function you want.
  *
  * @ingroup aux_util
+ * @relates xrt_hmd_parts
  */
 void
 u_distortion_mesh_from_panotools(const struct u_panotools_values *left,
···
  * Create two distortion meshes with no distortion.
  *
  * @ingroup aux_util
+ * @relates xrt_hmd_parts
  */
 void
 u_distortion_mesh_none(struct xrt_hmd_parts *target);

src/xrt/auxiliary/util/u_sink.h

···
 extern "C" {
 #endif
 
-
+/*!
+ * @see u_sink_quirk_create
+ */
 struct u_sink_quirk_params
 {
 	bool stereo_sbs;
···
 	bool leap_motion;
 };
 
+/*!
+ * @relatesalso xrt_frame_sink
+ * @relates xrt_frame_context
+ */
 void
 u_sink_create_format_converter(struct xrt_frame_context *xfctx,
                                enum xrt_format f,
                                struct xrt_frame_sink *downstream,
                                struct xrt_frame_sink **out_xfs);
 
+/*!
+ * @relatesalso xrt_frame_sink
+ * @relates xrt_frame_context
+ */
 void
 u_sink_create_to_r8g8b8_or_l8(struct xrt_frame_context *xfctx,
                               struct xrt_frame_sink *downstream,
                               struct xrt_frame_sink **out_xfs);
 
+/*!
+ * @relatesalso xrt_frame_sink
+ * @relates xrt_frame_context
+ */
 void
 u_sink_create_to_yuv_yuyv_uyvy_or_l8(struct xrt_frame_context *xfctx,
                                      struct xrt_frame_sink *downstream,
                                      struct xrt_frame_sink **out_xfs);
 
+/*!
+ * @relatesalso xrt_frame_sink
+ * @relates xrt_frame_context
+ */
 void
 u_sink_create_to_yuv_or_yuyv(struct xrt_frame_context *xfctx,
                              struct xrt_frame_sink *downstream,
                              struct xrt_frame_sink **out_xfs);
-
+/*!
+ * @public @memberof u_sink_deinterleaver
+ * @relatesalso xrt_frame_sink
+ * @relates xrt_frame_context
+ */
 void
 u_sink_deinterleaver_create(struct xrt_frame_context *xfctx,
                             struct xrt_frame_sink *downstream,
                             struct xrt_frame_sink **out_xfs);
 
+/*!
+ * @public @memberof u_sink_queue
+ * @relatesalso xrt_frame_sink
+ * @relates xrt_frame_context
+ */
 bool
 u_sink_queue_create(struct xrt_frame_context *xfctx,
                     struct xrt_frame_sink *downstream,
                     struct xrt_frame_sink **out_xfs);
 
+/*!
+ * @public @memberof u_sink_quirk
+ * @relatesalso xrt_frame_sink
+ * @relates xrt_frame_context
+ */
 void
 u_sink_quirk_create(struct xrt_frame_context *xfctx,
                     struct xrt_frame_sink *downstream,
                     struct u_sink_quirk_params *params,
                     struct xrt_frame_sink **out_xfs);
 
+/*!
+ * @public @memberof u_sink_split
+ * @relatesalso xrt_frame_sink
+ */
 void
 u_sink_split_create(struct xrt_frame_context *xfctx,
                     struct xrt_frame_sink *left,

src/xrt/auxiliary/util/u_sink_converter.c

···
  *
  */
 
+/*!
+ * An @ref xrt_frame_sink that converts frames.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct u_sink_converter
 {
 	struct xrt_frame_sink base;

src/xrt/auxiliary/util/u_sink_deinterleaver.c

···
 // SPDX-License-Identifier: BSL-1.0
 /*!
  * @file
- * @brief  A @ref xrt_frame_sink that deinterleaves stereo frames.
+ * @brief  An @ref xrt_frame_sink that deinterleaves stereo frames.
  * @author Pete Black <[e-mail]>
  * @author Jakob Bornecrantz <[e-mail]>
  * @ingroup aux_util
···
 #include "util/u_frame.h"
 
 
+/*!
+ * An @ref xrt_frame_sink that deinterleaves stereo frames.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct u_sink_deinterleaver
 {
 	struct xrt_frame_sink base;

src/xrt/auxiliary/util/u_sink_queue.c

···
 // SPDX-License-Identifier: BSL-1.0
 /*!
  * @file
- * @brief  A @ref xrt_frame_sink queue.
+ * @brief  An @ref xrt_frame_sink queue.
  * @author Jakob Bornecrantz <[e-mail]>
  * @ingroup aux_util
  */
···
 #include <pthread.h>
 
 
+/*!
+ * An @ref xrt_frame_sink queue.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct u_sink_queue
 {
 	struct xrt_frame_sink base;

src/xrt/auxiliary/util/u_sink_quirk.c

···
 // SPDX-License-Identifier: BSL-1.0
 /*!
  * @file
- * @brief  A @ref xrt_frame_sink that quirks frames.
+ * @brief  An @ref xrt_frame_sink that quirks frames.
  * @author Jakob Bornecrantz <[e-mail]>
  * @ingroup aux_util
  */
···
 #include "util/u_misc.h"
 #include "util/u_sink.h"
 
-
+/*!
+ * An @ref xrt_frame_sink that quirks frames.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct u_sink_quirk
 {
 	struct xrt_frame_sink base;

src/xrt/auxiliary/util/u_sink_split.c

···
 // SPDX-License-Identifier: BSL-1.0
 /*!
  * @file
- * @brief  A @ref xrt_frame_sink splitter.
+ * @brief  An @ref xrt_frame_sink splitter.
  * @author Jakob Bornecrantz <[e-mail]>
  * @ingroup aux_util
  */
···
 #include "util/u_sink.h"
 
 
+/*!
+ * An @ref xrt_frame_sink splitter.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct u_sink_split
 {
 	struct xrt_frame_sink base;

src/xrt/compositor/client/comp_gl_client.h

···
  */
 
 /*!
+ * @class client_gl_swapchain
+ *
  * Wraps the real compositor swapchain providing a OpenGL based interface.
  *
  * Almost a one to one mapping to a OpenXR swapchain.
  *
  * @ingroup comp_client
+ * @implements xrt_swapchain_gl
  */
 struct client_gl_swapchain
 {
···
 };
 
 /*!
+ * @class client_gl_compositor
+ *
  * Wraps the real compositor providing a OpenGL based interface.
  *
  * @ingroup comp_client
+ * @implements xrt_compositor_gl
  */
 struct client_gl_compositor
 {
···
  */
 
 /*!
- * Convenience function to convert a xrt_swapchain to a client_gl_swapchain.
+ * Down-cast helper.
+ * @private @memberof client_gl_swapchain
  */
 static inline struct client_gl_swapchain *
 client_gl_swapchain(struct xrt_swapchain *xsc)
···
 }
 
 /*!
- * Convenience function to convert a xrt_compositor to a client_gl_compositor.
+ * Down-cast helper.
+ * @private @memberof client_gl_compositor
  */
 static inline struct client_gl_compositor *
 client_gl_compositor(struct xrt_compositor *xc)
···
 
 /*!
  * Fill in a client_gl_compositor and do common OpenGL sanity checking.
+ *
+ * OpenGL can have multiple backing window systems we have to interact with, so
+ * there isn't just one unified OpenGL client constructor.
+ *
+ * @public @memberof client_gl_compositor
+ * @relatesalso xrt_compositor_fd
  */
 bool
 client_gl_compositor_init(struct client_gl_compositor *c,

src/xrt/compositor/client/comp_gl_xlib_client.h

···
 
 
 /*!
+ * @class client_gl_xlib_compositor
  * A client facing xlib OpenGL base compositor.
  *
  * @ingroup comp_client
+ * @extends client_gl_compositor
  */
 struct client_gl_xlib_compositor
 {
···
 };
 
 /*!
- * Convenience function to convert a xrt_compositor to a
- * client_gl_xlib_compositor.
+ * Down-cast helper.
  *
- * @ingroup comp_client
+ * @private @memberof client_gl_xlib_compositor
  */
 static inline struct client_gl_xlib_compositor *
 client_gl_xlib_compositor(struct xrt_compositor *xc)
···
 /*!
  * Create a new client_gl_xlib_compositor.
  *
- * @ingroup comp_client
+ * @public @memberof client_gl_xlib_compositor
+ * @relatesalso xrt_compositor_fd
  */
 struct client_gl_xlib_compositor *
 client_gl_xlib_compositor_create(struct xrt_compositor_fd *xcfd,

src/xrt/compositor/client/comp_vk_client.h

···
  * Almost a one to one mapping to a OpenXR swapchain.
  *
  * @ingroup comp_client
+ * @implements xrt_swapchain_vk
  */
 struct client_vk_swapchain
 {
 	struct xrt_swapchain_vk base;
+
+	//! Owning reference to the backing fd swapchain.
 	struct xrt_swapchain_fd *xscfd;
+
+	//! Non-owning reference to our parent compositor.
 	struct client_vk_compositor *c;
 };
 
 /*!
+ * @class client_vk_compositor
+ *
  * Wraps the real compositor providing a Vulkan based interface.
  *
  * @ingroup comp_client
+ * @implements xrt_compositor_vk
  */
 struct client_vk_compositor
 {
 	struct xrt_compositor_vk base;
 
+	//! Owning reference to the backing fd compositor
 	struct xrt_compositor_fd *xcfd;
 
 	struct vk_bundle vk;
···
  */
 
 /*!
- * Convenience function to convert a xrt_swapchain to a client_vk_swapchain.
+ * Down-cast helper.
  *
- * @ingroup comp_client
+ * @private @memberof client_vk_swapchain
  */
 static inline struct client_vk_swapchain *
 client_vk_swapchain(struct xrt_swapchain *xsc)
···
 }
 
 /*!
- * Convenience function to convert a xrt_compositor to a client_vk_compositor.
+ * Down-cast helper.
  *
- * @ingroup comp_client
+ * @private @memberof client_vk_compositor
  */
 static inline struct client_vk_compositor *
 client_vk_compositor(struct xrt_compositor *xc)
···
 /*!
  * Create a new client_vk_compositor.
  *
- * @ingroup comp_client
+ * @public @memberof client_vk_compositor
+ * @relatesalso xrt_compositor_fd
  */
 struct client_vk_compositor *
 client_vk_compositor_create(struct xrt_compositor_fd *xcfd,

src/xrt/compositor/main/comp_compositor.h

···
  * A single swapchain image, holds the needed state for tracking image usage.
  *
  * @ingroup comp_main
+ * @see comp_swapchain
  */
 struct comp_swapchain_image
 {
···
  * Not used by the window backend that uses the vk_swapchain to render to.
  *
  * @ingroup comp_main
+ * @implements xrt_swapchain_fd
+ * @see comp_compositor
  */
 struct comp_swapchain
 {
···
 	 */
 	struct u_index_fifo fifo;
 };
-
+/*!
+ * Tag for distinguishing the union contents of @ref comp_layer.
+ */
 enum comp_layer_type
 {
+	//! comp_layer::stereo is initialized
 	COMP_LAYER_STEREO_PROJECTION,
+	//! comp_layer::quad is initialized
 	COMP_LAYER_QUAD,
 };
 
···
  * A quad layer.
  *
  * @ingroup comp_main
+ * @see comp_layer
  */
 struct comp_layer_quad
 {
···
  * A stereo projection layer.
  *
  * @ingroup comp_main
+ * @see comp_layer
  */
 struct comp_layer_stereo
 {
···
  * A single layer.
  *
  * @ingroup comp_main
+ * @see comp_layer_slot
  */
 struct comp_layer
 {
···
  * A stack of layers.
  *
  * @ingroup comp_main
+ * @see comp_compositor
  */
 struct comp_layer_slot
 {
···
  * Main compositor struct tying everything in the compositor together.
  *
  * @ingroup comp_main
+ * @implements xrt_compositor_fd
  */
 struct comp_compositor
 {
···
 /*!
  * Convenience function to convert a xrt_swapchain to a comp_swapchain.
  *
- * @ingroup comp_main
+ * @private @memberof comp_swapchain
  */
 static inline struct comp_swapchain *
 comp_swapchain(struct xrt_swapchain *xsc)
···
 /*!
  * Convenience function to convert a xrt_compositor to a comp_compositor.
  *
- * @ingroup comp_main
+ * @private @memberof comp_compositor
  */
 static inline struct comp_compositor *
 comp_compositor(struct xrt_compositor *xc)
···
  * Do garbage collection, destroying any resources that has been scheduled for
  * destruction from other threads.
  *
- * @ingroup comp_main
+ * @public @memberof comp_compositor
  */
 void
 comp_compositor_garbage_collect(struct comp_compositor *c);
···
 /*!
  * A compositor function that is implemented in the swapchain code.
  *
- * @ingroup comp_main
+ * @public @memberof comp_compositor
  */
 struct xrt_swapchain *
 comp_swapchain_create(struct xrt_compositor *xc,
···
  * does the actual destruction and is called from @ref
  * comp_compositor_garbage_collect.
  *
- * @ingroup comp_main
+ * @private @memberof comp_swapchain
  */
 void
 comp_swapchain_really_destroy(struct comp_swapchain *sc);
···
 /*!
  * Printer helper.
  *
- * @ingroup comp_main
+ * @public @memberof comp_compositor
  */
 void
 comp_compositor_print(struct comp_compositor *c,
···
 /*!
  * Spew level logging.
  *
- * @ingroup comp_main
+ * @relates comp_compositor
  */
 #define COMP_SPEW(c, ...)                                                      \
 	do {                                                                   \
···
 /*!
  * Debug level logging.
  *
- * @ingroup comp_main
+ * @relates comp_compositor
  */
 #define COMP_DEBUG(c, ...)                                                     \
 	do {                                                                   \
···
 /*!
  * Mode printing.
  *
- * @ingroup comp_main
+ * @relates comp_compositor
  */
 #define COMP_PRINT_MODE(c, ...)                                                \
 	do {                                                                   \
···
 /*!
  * Error level logging.
  *
- * @ingroup comp_main
+ * @relates comp_compositor
  */
 #define COMP_ERROR(c, ...)                                                     \
 	do {                                                                   \

src/xrt/compositor/main/comp_window.h

···
  */
 
 /*!
+ * @interface comp_window
  * A output device or a window, often directly connected to the device.
  *
  * @ingroup comp_main
···
  * Create a xcb window.
  *
  * @ingroup comp_main
+ * @public @memberof comp_window_xcb
  */
 struct comp_window *
 comp_window_xcb_create(struct comp_compositor *c);
···
  * Create a wayland window.
  *
  * @ingroup comp_main
+ * @public @memberof comp_window_wayland
  */
 struct comp_window *
 comp_window_wayland_create(struct comp_compositor *c);
···
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
 /*!
- * Create a direct surface to a HMD over RandR.
+ * Create a direct surface to an HMD over RandR.
  *
  * @ingroup comp_main
+ * @public @memberof comp_window_direct_randr
  */
 struct comp_window *
 comp_window_direct_randr_create(struct comp_compositor *c);
 
 /*!
- * Create a direct surface to a HMD on NVIDIA.
+ * Create a direct surface to an HMD on NVIDIA.
  *
  * @ingroup comp_main
+ * @public @memberof comp_window_direct_nvidia
  */
 struct comp_window *
 comp_window_direct_nvidia_create(struct comp_compositor *c);

src/xrt/compositor/main/comp_window_direct_nvidia.c

···
 /*!
  * Direct mode "window" into a device, using Vulkan direct mode extension
  * and xcb.
+ *
+ * @implements comp_window
  */
 struct comp_window_direct_nvidia
 {
···
 
 /*
  *
- * Pre decalre functions
+ * Forward declare functions
  *
  */
 

src/xrt/compositor/main/comp_window_direct_randr.c

···
 /*!
  * Direct mode "window" into a device, using Vulkan direct mode extension
  * and xcb.
+ *
+ * @implements comp_window
  */
 struct comp_window_direct_randr
 {
···
 
 /*
  *
- * Pre decalre functions
+ * Forward declare functions
  *
  */
 

src/xrt/compositor/main/comp_window_wayland.c

···
 
 /*!
  * A Wayland connection and window.
+ *
+ * @implements comp_window
  */
 struct comp_window_wayland
 {

src/xrt/compositor/main/comp_window_xcb.c

···
 
 /*!
  * A xcb connection and window.
+ *
+ * @implements comp_window
  */
 struct comp_window_xcb
 {

src/xrt/drivers/arduino/arduino_device.c

···
 	struct arduino_parsed_sample sample;
 };
 
+/*!
+ * @implements xrt_device
+ */
 struct arduino_device
 {
 	struct xrt_device base;

src/xrt/drivers/arduino/arduino_prober.c

···
  * Arduino prober struct.
  *
  * @ingroup drv_arduino
+ * @implements xrt_auto_prober
  */
 struct arduino_prober
 {
···
  *
  */
 
+//! @private @memberof arduino_prober
 static inline struct arduino_prober *
 arduino_prober(struct xrt_auto_prober *p)
 {
 	return (struct arduino_prober *)p;
 }
 
+//! @public @memberof arduino_prober
 static void
 arduino_prober_destroy(struct xrt_auto_prober *p)
 {
···
 	free(ap);
 }
 
+//! @public @memberof arduino_prober
 static struct xrt_device *
 arduino_prober_autoprobe(struct xrt_auto_prober *xap,
                          cJSON *attached_data,

src/xrt/drivers/daydream/daydream_device.h

···
 	struct daydream_parsed_sample sample;
 };
 
+/*!
+ * @implements xrt_device
+ */
 struct daydream_device
 {
 	struct xrt_device base;

src/xrt/drivers/daydream/daydream_prober.c

···
  *
  */
 
-// Should the experimental PSVR driver be enabled.
+// Should the experimental Daydream driver be enabled.
 DEBUG_GET_ONCE_BOOL_OPTION(daydream_enable, "DAYDREAM_ENABLE", true)
 DEBUG_GET_ONCE_BOOL_OPTION(daydream_spew, "DAYDREAM_PRINT_SPEW", false)
 DEBUG_GET_ONCE_BOOL_OPTION(daydream_debug, "DAYDREAM_PRINT_DEBUG", false)
···
  * Daydream prober struct.
  *
  * @ingroup drv_daydream
+ * @implements xrt_auto_prober
  */
 struct daydream_prober
 {
···
  *
  */
 
+//! @private @memberof daydream_prober
 static inline struct daydream_prober *
 daydream_prober(struct xrt_auto_prober *p)
 {
 	return (struct daydream_prober *)p;
 }
 
+//! @public @memberof daydream_prober
 static void
 daydream_prober_destroy(struct xrt_auto_prober *p)
 {
···
 	free(pdaydream);
 }
 
+//! @public @memberof daydream_prober
 static struct xrt_device *
 daydream_prober_autoprobe(struct xrt_auto_prober *xap,
                           cJSON *attached_data,

src/xrt/drivers/dummy/dummy_hmd.c

···
  *
  */
 
+/*!
+ * @implements xrt_device
+ */
 struct dummy_hmd
 {
 	struct xrt_device base;

src/xrt/drivers/dummy/dummy_prober.c

···
 
 #include "dummy_interface.h"
 
-
+/*!
+ * @implements xrt_auto_prober
+ */
 struct dummy_prober
 {
 	struct xrt_auto_prober base;
 };
 
+//! @private @memberof dummy_prober
 static inline struct dummy_prober *
 dummy_prober(struct xrt_auto_prober *p)
 {
 	return (struct dummy_prober *)p;
 }
 
+//! @public @memberof dummy_prober
 static void
 dummy_prober_destroy(struct xrt_auto_prober *p)
 {
···
 	free(dp);
 }
 
+//! @public @memberof dummy_prober
 static struct xrt_device *
 dummy_prober_autoprobe(struct xrt_auto_prober *xap,
                        cJSON *attached_data,

src/xrt/drivers/hdk/hdk_device.h

···
 	HDK_VARIANT_2
 };
 
+/*!
+ * @implements xrt_device
+ */
 struct hdk_device
 {
 	struct xrt_device base;

src/xrt/drivers/hydra/hydra_driver.c

···
  * A Razer Hydra system containing two controllers.
  *
  * @ingroup drv_hydra
+ * @extends xrt_tracking_origin
  */
 struct hydra_system
 {
···
  * A Razer Hydra device, representing just a single controller.
  *
  * @ingroup drv_hydra
+ * @implements xrt_device
  */
 struct hydra_device
 {

src/xrt/drivers/north_star/ns_hmd.h

···
  * Information about the whole North Star headset.
  *
  * @ingroup drv_ns
+ * @implements xrt_device
  */
 struct ns_hmd
 {
···
  * The mesh generator for the North Star distortion.
  *
  * @ingroup drv_ns
+ * @implements u_uv_generator
  */
 struct ns_mesh
 {

src/xrt/drivers/north_star/ns_prober.c

···
 DEBUG_GET_ONCE_BOOL_OPTION(ns_spew, "NS_PRINT_SPEW", false)
 DEBUG_GET_ONCE_BOOL_OPTION(ns_debug, "NS_PRINT_DEBUG", false)
 
+/*!
+ * @implements xrt_auto_prober
+ */
 struct ns_prober
 {
 	struct xrt_auto_prober base;
···
 	bool print_debug;
 };
 
+//! @private @memberof ns_prober
 static inline struct ns_prober *
 ns_prober(struct xrt_auto_prober *p)
 {
 	return (struct ns_prober *)p;
 }
 
+//! @public @memberof ns_prober
 static void
 ns_prober_destroy(struct xrt_auto_prober *p)
 {
···
 	free(nsp);
 }
 
+//! @public @memberof ns_prober
 static struct xrt_device *
 ns_prober_autoprobe(struct xrt_auto_prober *xap,
                     cJSON *attached_data,

src/xrt/drivers/ohmd/oh_device.h

···
 typedef struct ohmd_context ohmd_context;
 typedef struct ohmd_device ohmd_device;
 
+/*!
+ * @implements xrt_device
+ */
 struct oh_device
 {
 	struct xrt_device base;

src/xrt/drivers/ohmd/oh_prober.c

···
 DEBUG_GET_ONCE_BOOL_OPTION(oh_debug, "OH_PRINT_DEBUG", false)
 DEBUG_GET_ONCE_BOOL_OPTION(oh_external, "OH_EXTERNAL_DRIVER", false)
 
+/*!
+ * @implements xrt_auto_prober
+ */
 struct oh_prober
 {
 	struct xrt_auto_prober base;
···
 	bool print_debug;
 };
 
+//! @private @memberof oh_prober
 static inline struct oh_prober *
 oh_prober(struct xrt_auto_prober *p)
 {
 	return (struct oh_prober *)p;
 }
 
+//! @public @memberof oh_prober
 static void
 oh_prober_destroy(struct xrt_auto_prober *p)
 {
···
 	free(ohp);
 }
 
+//! @public @memberof oh_prober
 static struct xrt_device *
 oh_prober_autoprobe(struct xrt_auto_prober *xap,
                     cJSON *attached_data,

src/xrt/drivers/psmv/psmv_driver.c

···
  * Translated to axis that means the ball is on the Y+ axis, the buttons on the
  * Z+ axis, the trigger on the Z- axis, the USB port on the Y- axis, the start
  * button on the X+ axis, select button on the X- axis.
+ *
+ * @implements xrt_device
  */
 struct psmv_device
 {

src/xrt/drivers/psvr/psvr_device.c

···
  * Private struct for the @ref drv_psvr device.
  *
  * @ingroup drv_psvr
+ * @implements xrt_device
  */
 struct psvr_device
 {

src/xrt/drivers/psvr/psvr_interface.h

···
  * Create a probe for PSVR devices.
  *
  * @ingroup drv_psvr
+ * @relates xrt_auto_prober
  */
 struct xrt_auto_prober *
 psvr_create_auto_prober(void);

src/xrt/drivers/psvr/psvr_prober.c

···
  * PSVR prober struct.
  *
  * @ingroup drv_psvr
+ * @implements xrt_auto_prober
  */
 struct psvr_prober
 {
···
  *
  */
 
+//! @private @memberof psvr_prober
 static inline struct psvr_prober *
 psvr_prober(struct xrt_auto_prober *p)
 {
 	return (struct psvr_prober *)p;
 }
 
+//! @public @memberof psvr_prober
 static void
 psvr_prober_destroy(struct xrt_auto_prober *p)
 {
···
 	free(ppsvr);
 }
 
+//! @public @memberof psvr_prober
 static struct xrt_device *
 psvr_prober_autoprobe(struct xrt_auto_prober *xap,
                       cJSON *attached_data,

src/xrt/drivers/realsense/rs_6dof.c

···
 
 
 
+/*!
+ * @implements xrt_device
+ */
 struct rs_6dof
 {
 	struct xrt_device base;

src/xrt/drivers/survive/survive_driver.c

···
 static bool survive_already_initialized = false;
 
 #define MAX_PENDING_EVENTS 30
+
+/*!
+ * @implements xrt_device
+ */
 struct survive_device
 {
 	struct xrt_device base;
···
 	VIVE_VARIANT_INDEX
 };
 
+/*!
+ * @extends xrt_tracking_origin
+ */
 struct survive_system
 {
 	struct xrt_tracking_origin base;

src/xrt/drivers/v4l2/v4l2_driver.c

···
  *
  */
 
+/*!
+ * Spew level logging.
+ *
+ * Outputs a line, from the given format string and arguments, only if
+ * v4l2_fs::print_spew is true.
+ * @relates v4l2_fs
+ */
 #define V_SPEW(p, ...)                                                         \
 	do {                                                                   \
 		if (p->print_spew) {                                           \
···
 		}                                                              \
 	} while (false)
 
+/*!
+ * Debug level logging.
+ *
+ * Outputs a line, from the given format string and arguments, only if
+ * v4l2_fs::print_debug is true.
+ *
+ * @relates v4l2_fs
+ */
 #define V_DEBUG(p, ...)                                                        \
 	do {                                                                   \
 		if (p->print_debug) {                                          \
···
 		}                                                              \
 	} while (false)
 
+/*!
+ * Error level logging.
+ *
+ * Outputs a line, from the given format string and arguments.
+ *
+ * @relates v4l2_fs
+ */
 #define V_ERROR(p, ...)                                                        \
 	do {                                                                   \
 		fprintf(stderr, "%s - ", __func__);                            \
···
  *
  */
 
+/*!
+ * @extends xrt_frame
+ * @ingroup drv_v4l2
+ */
 struct v4l2_frame
 {
 	struct xrt_frame base;
···
 	struct v4l2_buffer v_buf;
 };
 
+/*!
+ * @ingroup drv_v4l2
+ */
 struct v4l2_control_state
 {
 	int force;
···
 };
 
 /*!
- * A single open v4l2 capture device, starts it's own thread and waits on it.
+ * A single open v4l2 capture device, starts its own thread and waits on it.
+ *
+ * @implements xrt_frame_node
+ * @implements xrt_fs
  */
 struct v4l2_fs
 {

src/xrt/drivers/v4l2/v4l2_interface.h

···
  * Descriptor of a v4l2 source.
  *
  * @ingroup drv_v4l2
+ * @extends xrt_fs_mode
  */
 struct v4l2_source_descriptor
 {

src/xrt/drivers/vive/vive_controller_driver.c

···
  * A Vive Controller device, representing just a single controller.
  *
  * @ingroup drv_vive
+ * @implements xrt_device
  */
 struct vive_controller_device
 {

src/xrt/drivers/vive/vive_device.h

···
 	VIVE_VARIANT_INDEX
 };
 
+/*!
+ * @implements xrt_device
+ */
 struct vive_device
 {
 	struct xrt_device base;

src/xrt/include/xrt/xrt_compositor.h

···
 };
 
 /*!
- * Common swapchain base.
+ * @interface xrt_swapchain
+ * Common swapchain interface/base.
  *
  * @ingroup xrt_iface
  */
···
 };
 
 /*!
- * Helper for xrt_swapchain::acquire_image.
+ * @copydoc xrt_swapchain::acquire_image
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_swapchain
  */
 static inline bool
 xrt_swapchain_acquire_image(struct xrt_swapchain *xsc, uint32_t *index)
···
 }
 
 /*!
- * Helper for xrt_swapchain::wait_image.
+ * @copydoc xrt_swapchain::wait_image
+ *
+ * Helper for calling through the function pointer.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_swapchain
  */
 static inline bool
 xrt_swapchain_wait_image(struct xrt_swapchain *xsc,
···
 }
 
 /*!
- * Helper for xrt_swapchain::release_image.
+ * @copydoc xrt_swapchain::release_image
+ *
+ * Helper for calling through the function pointer.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_swapchain
  */
 static inline bool
 xrt_swapchain_release_image(struct xrt_swapchain *xsc, uint32_t index)
···
 }
 
 /*!
- * Helper for xrt_swapchain::destroy, does a null check and sets xc_ptr to
- * null if freed.
+ * @copydoc xrt_swapchain::destroy
+ *
+ * Helper for calling through the function pointer: does a null check and sets
+ * xsc_ptr to null if freed.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_swapchain
  */
 static inline void
 xrt_swapchain_destroy(struct xrt_swapchain **xsc_ptr)
···
 }
 
 /*!
- * Common compositor base.
+ * @interface xrt_compositor
+ *
+ * Common compositor client interface/base.
  *
  * @ingroup xrt_iface
  */
···
 	void (*discard_frame)(struct xrt_compositor *xc);
 
 	/*!
-	 * Begins layer submission, this and the other layer_* calls equivalent
-	 * to xrEndFrame, except over multiple class. It's only after
+	 * Begins layer submission, this and the other layer_* calls are
+	 * equivalent to xrEndFrame, except over multiple calls. It's only after
 	 * @p layer_commit that layers will be displayed. From the point of view
 	 * of the swapchain the image is used as soon as it's given in a call.
 	 */
···
 	/*!
 	 * Adds a stereo projection layer for submissions.
 	 *
+	 * @param xc          Self pointer
 	 * @param timestamp     When should this layer be shown.
 	 * @param xdev          The device the layer is relative to.
 	 * @param name          Which pose this layer is relative to.
···
 	 * Adds a quad layer for submission, the center of the quad is specified
 	 * by the pose and extends outwards from it.
 	 *
+	 * @param xc          Self pointer
 	 * @param timestamp   When should this layer be shown.
 	 * @param xdev        The device the layer is relative to.
 	 * @param name        Which pose this layer is relative to.
···
 };
 
 /*!
- * Helper for xrt_compositor::create_swapchain
+ * @copydoc xrt_compositor::create_swapchain
+ *
+ * Helper for calling through the function pointer.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_compositor
  */
 static inline struct xrt_swapchain *
 xrt_comp_create_swapchain(struct xrt_compositor *xc,
···
 }
 
 /*!
- * Helper for xrt_compositor::poll_events
+ * @copydoc xrt_compositor::poll_events
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_poll_events(struct xrt_compositor *xc, uint64_t *WIP)
···
 }
 
 /*!
- * Helper for xrt_compositor::prepare_session
+ * @copydoc xrt_compositor::prepare_session
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_prepare_session(struct xrt_compositor *xc)
···
 }
 
 /*!
- * Helper for xrt_compositor::begin_session
+ * @copydoc xrt_compositor::begin_session
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_begin_session(struct xrt_compositor *xc, enum xrt_view_type view_type)
···
 }
 
 /*!
- * Helper for xrt_compositor::end_session
+ * @copydoc xrt_compositor::end_session
+ *
+ * Helper for calling through the function pointer.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_end_session(struct xrt_compositor *xc)
···
 }
 
 /*!
- * Helper for xrt_compositor::wait_frame
+ * @copydoc xrt_compositor::wait_frame
+ *
+ * Helper for calling through the function pointer.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_wait_frame(struct xrt_compositor *xc,
···
 }
 
 /*!
- * Helper for xrt_compositor::begin_frame
+ * @copydoc xrt_compositor::begin_frame
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_begin_frame(struct xrt_compositor *xc)
···
 }
 
 /*!
- * Helper for xrt_compositor::discard_frame
+ * @copydoc xrt_compositor::discard_frame
+ *
+ * Helper for calling through the function pointer.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_discard_frame(struct xrt_compositor *xc)
···
 }
 
 /*!
- * Helper for xrt_compositor::layer_begin
+ * @copydoc xrt_compositor::layer_begin
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_layer_begin(struct xrt_compositor *xc,
···
 }
 
 /*!
- * Helper for xrt_compositor::layer_stereo_projection
+ * @copydoc xrt_compositor::layer_stereo_projection
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_layer_stereo_projection(struct xrt_compositor *xc,
···
 }
 
 /*!
- * Helper for xrt_compositor::layer_quad
+ * @copydoc xrt_compositor::layer_quad
+ *
+ * Helper for calling through the function pointer.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_layer_quad(struct xrt_compositor *xc,
···
 }
 
 /*!
- * Helper for xrt_compositor::layer_commit
+ * @copydoc xrt_compositor::layer_commit
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_layer_commit(struct xrt_compositor *xc)
···
 }
 
 /*!
- * Helper for xrt_compositor::destroy, does a null check and sets xc_ptr to
- * null if freed.
+ * @copydoc xrt_compositor::destroy
+ *
+ * Helper for calling through the function pointer: does a null check and sets
+ * xc_ptr to null if freed.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_compositor
  */
 static inline void
 xrt_comp_destroy(struct xrt_compositor **xc_ptr)
···
  */
 
 /*!
+ * Base class for an OpenGL (ES) client swapchain.
  * @ingroup xrt_iface comp_client
+ * @extends xrt_swapchain
  */
 struct xrt_swapchain_gl
 {
+	//! @public Base
 	struct xrt_swapchain base;
 
 	// GLuint
···
 };
 
 /*!
+ * Base class for an OpenGL (ES) client compositor.
  * @ingroup xrt_iface comp_client
+ * @extends xrt_compositor
  */
 struct xrt_compositor_gl
 {
 	struct xrt_compositor base;
 };
 
+/*!
+ * Down-cast helper.
+ *
+ * @private @memberof xrt_swapchain_gl
+ *
+ * @todo unused - remove?
+ */
 static inline struct xrt_swapchain_gl *
 xrt_swapchain_gl(struct xrt_swapchain *xsc)
 {
 	return (struct xrt_swapchain_gl *)xsc;
 }
 
+/*!
+ * Down-cast helper.
+ *
+ * @private @memberof xrt_compositor_gl
+ *
+ * @todo unused - remove?
+ */
 static inline struct xrt_compositor_gl *
 xrt_compositor_gl(struct xrt_compositor *xc)
 {
···
  * Base class for a Vulkan client swapchain.
  *
  * @ingroup xrt_iface comp_client
+ * @extends xrt_swapchain
  */
 struct xrt_swapchain_vk
 {
+	//! @public Base
 	struct xrt_swapchain base;
 
 	VkImage images[XRT_MAX_SWAPCHAIN_IMAGES];
···
  * Base class for a Vulkan client compositor.
  *
  * @ingroup xrt_iface comp_client
+ * @extends xrt_compositor
  */
 struct xrt_compositor_vk
 {
+	//! @public Base
 	struct xrt_compositor base;
 };
 
+/*!
+ * Down-cast helper.
+ *
+ * @private @memberof xrt_swapchain_vk
+ *
+ * @todo unused - remove?
+ */
 static inline struct xrt_swapchain_vk *
 xrt_swapchain_vk(struct xrt_swapchain *xsc)
 {
 	return (struct xrt_swapchain_vk *)xsc;
 }
 
+/*!
+ * Down-cast helper.
+ *
+ * @private @memberof xrt_compositor_vk
+ *
+ * @todo unused - remove?
+ */
 static inline struct xrt_compositor_vk *
 xrt_compositor_vk(struct xrt_compositor *xc)
 {
···
  * A single image of a fd based swapchain.
  *
  * @ingroup xrt_iface comp
+ * @see xrt_swapchain_fd
  */
 struct xrt_image_fd
 {
···
 };
 
 /*!
- * A swapchain that exposes fd to be imported into a client API.
+ * @interface xrt_swapchain_fd
+ * Base class for a swapchain that exposes fd to be imported into a client API.
  *
  * @ingroup xrt_iface comp
+ * @extends xrt_swapchain
  */
 struct xrt_swapchain_fd
 {
+	//! @public Base
 	struct xrt_swapchain base;
 
 	struct xrt_image_fd images[XRT_MAX_SWAPCHAIN_IMAGES];
 };
 
 /*!
- * Main compositor.
+ * @interface xrt_compositor_fd
+ *
+ * Main compositor server interface.
  *
  * @ingroup xrt_iface comp
+ * @extends xrt_compositor
  */
 struct xrt_compositor_fd
 {
+	//! @public Base
 	struct xrt_compositor base;
 };
 
+/*!
+ * Down-cast helper.
+ *
+ * @public @memberof xrt_swapchain_fd
+ */
 static inline struct xrt_swapchain_fd *
 xrt_swapchain_fd(struct xrt_swapchain *xsc)
 {
 	return (struct xrt_swapchain_fd *)xsc;
 }
 
+/*!
+ * Down-cast helper.
+ *
+ * @public @memberof xrt_compositor_fd
+ *
+ * @todo unused - remove?
+ */
 static inline struct xrt_compositor_fd *
 xrt_compositor_fd(struct xrt_compositor *xc)
 {

src/xrt/include/xrt/xrt_device.h

···
 };
 
 /*!
+ * @interface xrt_device
+ *
  * A single HMD or input device.
  *
  * @ingroup xrt_iface
···
 
 /*!
  * Helper function for @ref xrt_device::update_inputs.
+ *
+ * @public @memberof xrt_device
  */
 static inline void
 xrt_device_update_inputs(struct xrt_device *xdev)
···
 
 /*!
  * Helper function for @ref xrt_device::get_tracked_pose.
+ *
+ * @public @memberof xrt_device
  */
 static inline void
 xrt_device_get_tracked_pose(struct xrt_device *xdev,
···
 
 /*!
  * Helper function for @ref xrt_device::set_output.
+ *
+ * @public @memberof xrt_device
  */
 static inline void
 xrt_device_set_output(struct xrt_device *xdev,
···
 
 /*!
  * Helper function for @ref xrt_device::get_view_pose.
+ *
+ * @public @memberof xrt_device
  */
 static inline void
 xrt_device_get_view_pose(struct xrt_device *xdev,
···
 
 /*!
  * Helper function for @ref xrt_device::destroy.
+ *
+ * @public @memberof xrt_device
  */
 static inline void
 xrt_device_destroy(struct xrt_device **xdev_ptr)

src/xrt/include/xrt/xrt_frame.h

···
 
 
 /*!
+ * @interface xrt_frame_sink
+ *
  * A object that is sent frames.
+ *
+ * All objects that implement @ref xrt_frame_sink **must** also implement @ref
+ * xrt_frame_node, and should take an @ref xrt_frame_context to register
+ * themselves with in their constructor.
  *
  * @ingroup xrt_iface
  */
···
 };
 
 /*!
+ * @interface xrt_frame_node
+ *
  * A interface object used for destroying a frame graph.
  *
  * @see container_of
···
  * @param[in] src Object to be have it's refcount increased @p dst is set to
  *                this.
  * @ingroup xrt_iface
+ * @relates xrt_frame
  */
 static inline void
 xrt_frame_reference(struct xrt_frame **dst, struct xrt_frame *src)
···
 /*!
  * Add a node to a context.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_frame_context
  */
 static inline void
 xrt_frame_context_add(struct xrt_frame_context *xfctx,
···
 }
 
 /*!
- * Destroy all child nodes, but free the context itself.
+ * Destroy all child nodes, but do not free the context itself.
  *
- * @ingroup xrt_iface
+ * @public @memberof xrt_frame_context
  */
 static inline void
 xrt_frame_context_destroy_nodes(struct xrt_frame_context *xfctx)

src/xrt/include/xrt/xrt_frameserver.h

···
  * floats for broad applicability.
  *
  * @ingroup xrt_iface
+ * @see xrt_fs
  */
 struct xrt_fs_capture_parameters
 {
···
 	float exposure;
 };
 
+/*!
+ * @see xrt_fs
+ * @ingroup xrt_iface
+ */
 struct xrt_fs_mode
 {
 	uint32_t width;
···
 };
 
 /*!
- * Frameserver that generates frame, multiple subframes (like stereo and
+ * @interface xrt_fs
+ * Frameserver that generates frames. Multiple subframes (like stereo and
  * mipmaps) can be generate in one frame.
  *
  * @ingroup xrt_iface
···
 	char name[512];
 
 	/*!
-	 * All frames produced by this frameserver is tagged with this id.
+	 * All frames produced by this frameserver are tagged with this id.
 	 */
 	uint64_t source_id;
 
···
  */
 
 /*!
- * Helper for xrt_fs::enumerate_modes.
+ * @copydoc xrt_fs::enumerate_modes
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_fs
  */
 static inline bool
 xrt_fs_enumerate_modes(struct xrt_fs *xfs,
···
 }
 
 /*!
- * Helper for xrt_fs::configure_capture.
+ * @copydoc xrt_fs::configure_capture
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_fs
  */
 static inline bool
 xrt_fs_configure_capture(struct xrt_fs *xfs,
···
 }
 
 /*!
- * Helper for xrt_fs::stream_start.
+ * @copydoc xrt_fs::stream_start
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_fs
  */
 static inline bool
 xrt_fs_stream_start(struct xrt_fs *xfs,
···
 }
 
 /*!
- * Helper for xrt_fs::stream_stop.
+ * @copydoc xrt_fs::stream_stop
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_fs
  */
 static inline bool
 xrt_fs_stream_stop(struct xrt_fs *xfs)
···
 }
 
 /*!
- * Helper for xrt_fs::is_running.
+ * @copydoc xrt_fs::is_running
  *
- * @ingroup xrt_iface
+ * Helper for calling through the function pointer.
+ *
+ * @public @memberof xrt_fs
  */
 static inline bool
 xrt_fs_is_running(struct xrt_fs *xfs)

src/xrt/include/xrt/xrt_gfx_egl.h

···
 struct time_state;
 
 /*!
+ * Create an OpenGL(ES) compositor client using EGL.
+ *
  * @ingroup xrt_iface
+ * @public @memberof xrt_compositor_fd
  */
 struct xrt_compositor_gl *
 xrt_gfx_provider_create_gl_egl(struct xrt_compositor_fd *xcfd,

src/xrt/include/xrt/xrt_gfx_fd.h

···
  * Creates the main fd compositor.
  *
  * @ingroup xrt_iface
+ * @relates xrt_compositor_fd
  */
 struct xrt_compositor_fd *
 xrt_gfx_provider_create_fd(struct xrt_device *xdev, bool flip_y);

src/xrt/include/xrt/xrt_gfx_vk.h

···
 xrt_gfx_vk_get_versions(struct xrt_api_requirements *ver);
 
 /*!
+ * Create a Vulkan compositor client.
+ *
  * @ingroup xrt_iface
+ * @public @memberof xrt_compositor_fd
  */
 struct xrt_compositor_vk *
 xrt_gfx_vk_provider_create(struct xrt_compositor_fd *xcfd,

src/xrt/include/xrt/xrt_gfx_xlib.h

···
 struct time_state;
 
 /*!
+ * Create an OpenGL compositor client using xlib.
+ *
  * @ingroup xrt_iface
+ * @public @memberof xrt_compositor_fd
  */
 struct xrt_compositor_gl *
 xrt_gfx_provider_create_gl_xlib(struct xrt_compositor_fd *xcfd,

src/xrt/include/xrt/xrt_instance.h

···
  */
 
 /*!
+ * @interface xrt_instance
+ *
  * This interface acts as a root object for Monado.
  * It typically either wraps an @ref xrt_prober or forms a connection to an
  * out-of-process XR service.
···
  * interface, which is exposed by implementing xrt_instance_create().
  *
  * Additional information can be found in @ref md_targets
+ *
+ * @sa ipc_instance_create
  */
 struct xrt_instance
 {
···
 };
 
 /*!
- * @name Method call helpers for xrt_instance
- * Calling code should prefer using these instead of directly using the function
- * pointer members.
- * @{
- */
-/*!
- * Helper function for @ref xrt_instance::select.
+ * @copydoc xrt_instance::select
  *
- * See @ref xrt_instance::select for documentation.
+ * Helper for calling through the function pointer.
  *
- * @relates xrt_instance
+ * @public @memberof xrt_instance
  */
 static inline int
 xrt_instance_select(struct xrt_instance *xinst,
···
 }
 
 /*!
- * Helper function for @ref xrt_instance::create_fd_compositor.
+ * @copydoc xrt_instance::create_fd_compositor
  *
- * See @ref xrt_instance::create_fd_compositor for documentation.
+ * Helper for calling through the function pointer.
  *
- * @relates xrt_instance
+ * @public @memberof xrt_instance
  */
 static inline int
 xrt_instance_create_fd_compositor(struct xrt_instance *xinst,
···
 }
 
 /*!
- * Helper function for @ref xrt_instance::get_prober.
+ * @copydoc xrt_instance::get_prober
  *
- * See @ref xrt_instance::get_prober for documentation.
+ * Helper for calling through the function pointer.
  *
- * @relates xrt_instance
+ * @public @memberof xrt_instance
  */
 static inline int
 xrt_instance_get_prober(struct xrt_instance *xinst, struct xrt_prober **out_xp)
···
 }
 
 /*!
- * Helper function for @ref xrt_instance::destroy.
+ * Destroy an xrt_instance - helper function.
  *
  * @param[in,out] xinst_ptr A pointer to your instance implementation pointer.
  *
  * Will destroy the instance if *xinst_ptr is not NULL. Will then set *xinst_ptr
  * to NULL.
  *
- * @relates xrt_instance
+ * @public @memberof xrt_instance
  */
 static inline void
 xrt_instance_destroy(struct xrt_instance **xinst_ptr)
···
 	xinst->destroy(xinst);
 	*xinst_ptr = NULL;
 }
-/*!
- * @}
- */
-
 
 /*!
  * @name Factory

src/xrt/include/xrt/xrt_prober.h

···
 /*!
  * Helper function for @ref xrt_prober::probe.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline int
 xrt_prober_probe(struct xrt_prober *xp)
···
 /*!
  * Helper function for @ref xrt_prober::dump.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline int
 xrt_prober_dump(struct xrt_prober *xp)
···
 /*!
  * Helper function for @ref xrt_prober::select.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline int
 xrt_prober_select(struct xrt_prober *xp,
···
 /*!
  * Helper function for @ref xrt_prober::open_hid_interface.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline int
 xrt_prober_open_hid_interface(struct xrt_prober *xp,
···
 /*!
  * Helper function for @ref xrt_prober::get_string_descriptor.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline int
 xrt_prober_get_string_descriptor(struct xrt_prober *xp,
···
 /*!
  * Helper function for @ref xrt_prober::can_open.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline bool
 xrt_prober_can_open(struct xrt_prober *xp, struct xrt_prober_device *xpdev)
···
 /*!
  * Helper function for @ref xrt_prober::xrt_prober_open_video_device.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline int
 xrt_prober_open_video_device(struct xrt_prober *xp,
···
 /*!
  * Helper function for @ref xrt_prober::list_video_devices.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline int
 xrt_prober_list_video_devices(struct xrt_prober *xp,
···
 /*!
  * Helper function for @ref xrt_prober::destroy.
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 static inline void
 xrt_prober_destroy(struct xrt_prober **xp_ptr)
···
  * created xrt_prober instance.
  * @param[in] list Prober entry list
  *
- * @ingroup xrt_iface
- * @relates xrt_prober
+ * @public @memberof xrt_prober
  */
 int
 xrt_prober_create_with_lists(struct xrt_prober **out_xp,
                              struct xrt_prober_entry_lists *list);
 
+/*!
+ * @public @memberof xrt_prober
+ */
 bool
 xrt_prober_match_string(struct xrt_prober *xp,
                         struct xrt_prober_device *dev,
···
  */
 
 /*!
- * A simple prober to probe for a HMD device connected to the system.
+ * @interface xrt_auto_prober
+ *
+ * An interface to be exposed by a device driver that should probe for the
+ * existence of its own device on the system, rather than using shared probers
+ * with vendor/product IDs, etc.
  *
  * @ingroup xrt_iface
  */

src/xrt/include/xrt/xrt_tracking.h

···
 
 /*!
  * A tracking system or device origin.
+ *
+ * Tracking systems will typically extend this structure.
  */
 struct xrt_tracking_origin
 {
···
 };
 
 /*!
+ * @interface xrt_tracking_factory
  * Tracking factory.
  */
 struct xrt_tracking_factory
···
 };
 
 /*!
+ * @interface xrt_tracked_psmv
+ *
  * A single tracked PS Move controller, camera and ball are not synced.
  *
  * @todo How do we communicate ball colour change?
···
 };
 
 /*!
+ * @interface xrt_tracked_psvr
+ *
  * A tracked PSVR headset.
  *
  * @todo How do we communicate led lighting status?
···
  *
  */
 
+//! @public @memberof xrt_tracked_psmv
 static inline void
 xrt_tracked_psmv_get_tracked_pose(struct xrt_tracked_psmv *psmv,
                                   enum xrt_input_name name,
···
 	psmv->get_tracked_pose(psmv, name, when_ns, out_relation);
 }
 
+//! @public @memberof xrt_tracked_psmv
 static inline void
 xrt_tracked_psmv_push_imu(struct xrt_tracked_psmv *psmv,
                           timepoint_ns timestamp_ns,
···
 	psmv->push_imu(psmv, timestamp_ns, sample);
 }
 
+//! @public @memberof xrt_tracked_psmv
 static inline void
 xrt_tracked_psmv_destroy(struct xrt_tracked_psmv **xtmv_ptr)
 {
···
 	*xtmv_ptr = NULL;
 }
 
+//! @public @memberof xrt_tracked_psmv
 static inline void
 xrt_tracked_psvr_get_tracked_pose(struct xrt_tracked_psvr *psvr,
                                   timepoint_ns when_ns,
···
 	psvr->get_tracked_pose(psvr, when_ns, out_relation);
 }
 
+//! @public @memberof xrt_tracked_psmv
 static inline void
 xrt_tracked_psvr_push_imu(struct xrt_tracked_psvr *psvr,
                           timepoint_ns timestamp_ns,
···
 	psvr->push_imu(psvr, timestamp_ns, sample);
 }
 
+//! @public @memberof xrt_tracked_psmv
 static inline void
 xrt_tracked_psvr_destroy(struct xrt_tracked_psvr **xtvr_ptr)
 {

src/xrt/ipc/ipc_client.h

···
 
 } ipc_connection_t;
 
-
+/*!
+ * @name IPC low-level interface
+ * These functions are called by generated IPC client code.
+ * @{
+ */
 ipc_result_t
 ipc_client_send_message(ipc_connection_t *ipc_c, void *message, size_t size);
 
···
                                   size_t reply_size,
                                   int *fds,
                                   size_t num_fds);
-
+/*!
+ * @}
+ */
 
 /*
  *

src/xrt/ipc/ipc_client_compositor.c

···
  * Internal structs and helpers.
  *
  */
-
+/*!
+ * Client proxy for an xrt_compositor_fd implementation over IPC.
+ * @implements xrt_compositor_fd
+ */
 struct ipc_client_compositor
 {
 	struct xrt_compositor_fd base;
···
 	} layers;
 };
 
+/*!
+ * Client proxy for an xrt_swapchain_fd implementation over IPC.
+ * @implements xrt_swapchain_fd
+ */
 struct ipc_client_swapchain
 {
 	struct xrt_swapchain_fd base;

src/xrt/ipc/ipc_client_device.c

···
  *
  */
 
+/*!
+ * An IPC client proxy for an @ref xrt_device.
+ * @implements xrt_device
+ */
 struct ipc_client_device
 {
 	struct xrt_device base;
···
 	}
 }
 
+/*!
+ * @public @memberof ipc_client_device
+ */
 struct xrt_device *
 ipc_client_device_create(ipc_connection_t *ipc_c,
                          struct xrt_tracking_origin *xtrack,

src/xrt/ipc/ipc_client_hmd.c

···
  *
  */
 
+/*!
+ * An IPC client proxy for an HMD @ref xrt_device.
+ * @implements xrt_device
+ */
 struct ipc_client_hmd
 {
 	struct xrt_device base;
···
 	}
 }
 
+/*!
+ * @public @memberof ipc_client_hmd
+ */
 struct xrt_device *
 ipc_client_hmd_create(ipc_connection_t *ipc_c,
                       struct xrt_tracking_origin *xtrack,

src/xrt/ipc/ipc_client_instance.c

···
  *
  */
 
+/*!
+ * @implements xrt_instance
+ */
 struct ipc_client_instance
 {
+	//! @public Base
 	struct xrt_instance base;
 
 	ipc_connection_t ipc_c;
···
  *
  */
 
+/*!
+ * Constructor for xrt_instance IPC client proxy.
+ *
+ * @public @memberof ipc_instance
+ */
 int
 ipc_instance_create(struct xrt_instance **out_xinst)
 {

src/xrt/state_trackers/gui/gui_common.h

···
 };
 
 /*!
+ * @interface gui_scene
  * A single currently running scene.
+ *
+ * @ingroup gui
  */
 struct gui_scene
 {

src/xrt/state_trackers/gui/gui_ogl.c

···
 #include <pthread.h>
 
 
+/*!
+ * An @ref xrt_frame_sink that shows sunk frames in the GUI.
+ * @implements xrt_frame_sink
+ * @implements xrt_frame_node
+ */
 struct gui_ogl_sink
 {
 	struct gui_ogl_texture tex;

src/xrt/state_trackers/gui/gui_scene_calibrate.c

···
 
 #include <assert.h>
 
-
+/*!
+ * An OpenCV-based camera calibration scene.
+ * @implements gui_scene
+ */
 struct calibration_scene
 {
 	struct gui_scene base;

src/xrt/state_trackers/gui/gui_scene_debug.c

···
 
 #include <float.h>
 
+/*!
+ * A GUI scene showing the variable tracking provided by @ref util/u_var.h
+ * @implements gui_scene
+ */
 struct debug_scene
 {
 	struct gui_scene base;

src/xrt/state_trackers/gui/gui_scene_main_menu.c

···
 
 static ImVec2 button_dims = {256, 0};
 
+/*!
+ * A main menu GUI scene allowing selection of which scene to proceed to.
+ * @implements gui_scene
+ */
 struct main_menu
 {
 	struct gui_scene base;

src/xrt/state_trackers/gui/gui_scene_video.c

···
 #include "gui_imgui.h"
 
 
+/*!
+ * A GUI scene that lets the user select a user device.
+ * @implements gui_scene
+ */
 struct video_select
 {
 	struct gui_scene base;

src/xrt/state_trackers/prober/p_prober.h

···
 #endif
 
 /*!
- * A prober device.
+ * A single device found by a @ref prober.
+ *
+ * @implements xrt_prober_device
  */
 struct prober_device
 {
···
 #endif
 };
 
+/*!
+ * @implements xrt_prober
+ */
 struct prober
 {
 	struct xrt_prober base;
···
 
 /*!
  * Load the JSON config file.
+ *
+ * @public @memberof prober
  */
 void
 p_json_open_or_create_main_file(struct prober *p);
 
 /*!
  * Extract tracking settings from the JSON.
+ *
+ * @public @memberof prober
+ * @relatesalso xrt_settings_tracking
  */
 bool
 p_json_get_tracking_settings(struct prober *p, struct xrt_settings_tracking *s);
 
 /*!
  * Dump the given device to stdout.
+ *
+ * @public @memberof prober
  */
 void
 p_dump_device(struct prober *p, struct prober_device *pdev, int id);
 
 /*!
  * Get or create a @ref prober_device from the device.
+ *
+ * @public @memberof prober
  */
 int
 p_dev_get_usb_dev(struct prober *p,
···
 
 /*!
  * Get or create a @ref prober_device from the device.
+ *
+ * @public @memberof prober
  */
 int
 p_dev_get_bluetooth_dev(struct prober *p,
···
                         struct prober_device **out_pdev);
 
 /*!
+ * @name Tracking systems
+ * @{
+ */
+/*!
  * Init the tracking factory.
+ *
+ * @private @memberof prober
+ * @relatesalso xrt_tracking_factory
  */
 int
 p_tracking_init(struct prober *p);
 
 /*!
  * Teardown the tracking factory.
+ *
+ * @private @memberof prober
+ * @relatesalso xrt_tracking_factory
  */
 void
 p_tracking_teardown(struct prober *p);
 
+/*!
+ * @}
+ */
+
 #ifdef XRT_HAVE_LIBUSB
+/*!
+ * @name libusb
+ * @{
+ */
+/*!
+ * @private @memberof prober
+ */
 int
 p_libusb_init(struct prober *p);
 
+/*!
+ * @private @memberof prober
+ */
 void
 p_libusb_teardown(struct prober *p);
 
+/*!
+ * @private @memberof prober
+ */
 int
 p_libusb_probe(struct prober *p);
 
+/*!
+ * @private @memberof prober
+ */
 int
 p_libusb_get_string_descriptor(struct prober *p,
                                struct prober_device *pdev,
···
                                unsigned char *buffer,
                                int length);
 
+/*!
+ * @private @memberof prober
+ */
 bool
 p_libusb_can_open(struct prober *p, struct prober_device *pdev);
+
+/*!
+ * @}
+ */
 #endif
 
 #ifdef XRT_HAVE_LIBUVC
+/*!
+ * @name libuvc
+ * @{
+ */
+/*!
+ * @private @memberof prober
+ */
 int
 p_libuvc_init(struct prober *p);
 
+/*!
+ * @private @memberof prober
+ */
 void
 p_libuvc_teardown(struct prober *p);
 
+/*!
+ * @private @memberof prober
+ */
 int
 p_libuvc_probe(struct prober *p);
+
+/*!
+ * @}
+ */
 #endif
 
 #ifdef XRT_HAVE_LIBUDEV
+/*!
+ * @name udev
+ * @{
+ */
+/*!
+ * @private @memberof prober
+ */
 int
 p_udev_probe(struct prober *p);
+/*!
+ * @}
+ */
 #endif

src/xrt/state_trackers/prober/p_tracking.c

···
  *
  */
 
+/*!
+ * @implements xrt_tracking_factory
+ * @extends xrt_tracking_origin
+ */
 struct p_factory
 {
 	//! Base struct.

src/xrt/targets/common/target_instance_parts.h

···
  *
  */
 
+/*!
+ * Main "real" instance implementation.
+ *
+ * Used in instances both with and without compositor access.
+ *
+ * @implements xrt_instance
+ */
 struct t_instance
 {
 	struct xrt_instance base;

src/xrt/targets/gui/gui_sdl2.h

···
  * Common struct holding state for the GUI interface.
  *
  * @ingroup gui
+ * @extends gui_program
  */
 struct sdl2_program
 {
···
 /*!
  * Init SDL2, create and show a window and bring up any other structs needed.
  *
- * @ingroup gui
+ * @public @memberof sdl2_program
  */
 int
 gui_sdl2_init(struct sdl2_program *p);
 
 /*!
- * Loop until user request quit and show Imgui interface.
+ * Loop until user requests quit, and show Imgui interface.
  *
- * @ingroup gui
+ * @public @memberof sdl2_program
  */
 void
 gui_sdl2_imgui_loop(struct sdl2_program *p);
···
 /*!
  * Loop until quit signal has been received.
  *
- * @ingroup gui
+ * @public @memberof sdl2_program
  */
 void
 gui_sdl2_loop(struct sdl2_program *p);
···
 /*!
  * Destroy all SDL things and quit SDL.
  *
- * @ingroup gui
+ * @public @memberof sdl2_program
  */
 void
 gui_sdl2_quit(struct sdl2_program *p);

src/xrt/targets/openxr/oxr_sdl2_hack.c

···
 
 /*!
  * Common struct holding state for the GUI interface.
+ * @extends gui_program
  */
 struct sdl2_program
 {