| Candroid_custom_surface | |
| Candroid_instance_base | A basic implementation of the xrt_instance_android interface, a platform-specific "aspect" of xrt_instance |
| Candroid_lifecycle_callbacks | An object handling a collection of callbacks for the Android lifecycle |
| Carduino_parsed_input | |
| Carduino_parsed_sample | A parsed sample of accel and gyro |
| Cipcproto.common.Arg | |
| Cxrt::tracking::hand::mercury::ArrayStack | |
| Cbindings.Availability | |
| CAxis | |
| Cbindings.Bindings | |
| Cble_conn_helper | Small helper that keeps track of a connection and a error |
| Cxrt::auxiliary::tracking::psvr::blob_data | |
| Cxrt::auxiliary::tracking::psvr::blob_point | |
| CBlockQueue | This interface is missing in the C++ header but present in the C one, and the lighthouse driver requires it |
| Cxrt::auxiliary::util::box_iou::Box | |
| Cbuild_state | |
| CButton | |
| Cxrt::auxiliary::tracking::Calibration | Main class for doing calibration |
| Cipcproto.common.Call | |
| ►CSurfaceHolder.Callback | |
| Corg.freedesktop.monado.auxiliary.MonadoView | |
| ►CSurfaceHolder.Callback2 | |
| Corg.freedesktop.monado.auxiliary.MonadoView | |
| Ccamera_window | |
| Cxrt::auxiliary::tracking::CameraCalibrationWrapper | Essential calibration data wrapped for C++ |
| Ccemu_device | |
| Ccemu_system | |
| Cmonado.Client | |
| Cclient_d3d11_swapchain_data | Split out from client_d3d11_swapchain to ensure that it is standard layout, std::vector for instance is not standard layout |
| Cclient_d3d12_swapchain_data | Split out from client_d3d12_swapchain to ensure that it is standard layout, std::vector for instance is not standard layout |
| Cclient_egl_compositor | EGL based compositor, carries the extra needed EGL information needed by the client side code and can handle both GL Desktop or GLES contexts |
| Cclient_egl_context | |
| Cclient_gl_context | |
| Cxrt::auxiliary::tracking::psvr::close_pair | |
| Ccomp_frame | Tracking frame state |
| Ccomp_frame_params | Additional per-frame parameters |
| Ccomp_layer | A single layer in a comp_layer_accum |
| Ccomp_layer_accum | Collect a stack of layers - one frame's worth |
| Ccomp_mirror_to_debug_gui | Helper struct for mirroring the compositors rendering to the debug ui, which also enables recording |
| Ccomp_render_dispatch_data | The input data needed for a complete layer squashing distortion rendering to a target |
| Ccomp_render_scratch_state | Holds an array of comp_scratch_view_state to match the number of views |
| Ccomp_render_view_data | The input data needed for a single view, shared between both GFX and CS paths |
| Ccomp_renderer | Holds associated vulkan objects and state to render with a distortion |
| Ccomp_scratch_indices | Small helper struct to deal with indices |
| Ccomp_scratch_single_images | Holds scratch images for a single view, designed to work with render code |
| Ccomp_scratch_stereo_images | Holds scartch images for a stereo views, designed to work with render code |
| Ccomp_scratch_view_state | |
| Ccomp_settings | Settings for the compositor |
| Ccomp_swapchain_image | A single swapchain image, holds the needed state for tracking image usage |
| Ccomp_swapchain_shared | Shared resource(s) and garbage collector for swapchains |
| Ccomp_target | A compositor target: where the compositor renders to |
| Ccomp_target_create_images_info | Information given in when creating the swapchain images, argument to comp_target_create_images |
| Ccomp_target_factory | A factory of targets |
| Ccomp_target_image | Image and view pair for comp_target |
| Ccomp_target_semaphores | Collection of semaphores needed for a target |
| ►Ccomp_target_swapchain | Wraps and manage VkSwapchainKHR and VkSurfaceKHR, used by Compositor code |
| Ccomp_window_android | An Android window |
| Ccomp_window_direct_nvidia | Direct mode "window" into a device, using Vulkan direct mode extension and xcb |
| Ccomp_window_direct_randr | Direct mode "window" into a device, using Vulkan direct mode extension and xcb |
| Ccomp_window_mswin | A Microsoft Windows window |
| Ccomp_window_vk_display | Direct mode "window" into a device, using PLATFORM_DISPLAY_KHR |
| Ccomp_window_wayland | A Wayland connection and window |
| Ccomp_window_xcb | A xcb connection and window |
| Ccomp_vulkan_arguments | Arguments to Vulkan bundle initialisation, all args needs setting |
| Ccomp_vulkan_formats | Struct with supported format, these are not only check for optimal flags but also the ability to import and export them |
| Ccomp_vulkan_results | Extra results from Vulkan bundle initialisation |
| Ccomp_window_direct_nvidia_display | Probed display |
| Ccomp_window_direct_randr_display | Probed display |
| Ccomp_window_direct_wayland | |
| Ccomp_window_peek | |
| Ccomp_window_xcb_display | Xcb display, xrandr output |
| Cbindings.Component | |
| Ccompute_distortion_params | |
| Ccompute_layer_params | |
| Cxrt::tracking::hand::mercury::lm::CostFunctor< optimize_hand_size > | |
| Cxrt::auxiliary::tracking::slam::CSVWriter< RowType > | Writes a CSV file for a particular row type |
| ►Cxrt::auxiliary::tracking::slam::CSVWriter< feature_count_sample > | |
| Cxrt::auxiliary::tracking::slam::FeaturesWriter | Writes feature information specific to a particular estimated pose |
| ►Cxrt::auxiliary::tracking::slam::CSVWriter< timing_sample > | |
| Cxrt::auxiliary::tracking::slam::TimingWriter | Writes timestamps measured when estimating a new pose by the SLAM system |
| ►Cxrt::auxiliary::tracking::slam::CSVWriter< xrt_pose_sample > | |
| Cxrt::auxiliary::tracking::slam::TrajectoryWriter | Writes poses and their timestamps to a CSV file |
| Ccurated_state | Extra state for curated debug UI |
| Cd3d11_allocator | |
| Cd3d12_allocator | |
| Cdaydream_input_packet | Input package for Daydream |
| Cdaydream_parsed_input | |
| Cdaydream_parsed_sample | A parsed sample of accel and gyro |
| Cdebug_record | A single record window, here only used to draw a single element in a object window, holds all the needed state |
| Cdepthai_fs | DepthAI frameserver support the Luxonis Oak devices |
| Cdepthai_slam_startup_settings | |
| CDepthAIFrameWrapper | Manage dai::ImgFrame life-time |
| Cxrt::tracking::hand::mercury::lm::DepthObservation< T > | |
| Cmonado.Device | |
| Cdevice_info | |
| CDeviceBuilder | |
| Cdirect_wayland_lease | |
| Cdirect_wayland_lease_connector | |
| Cdirect_wayland_lease_device | |
| Cdisplay_info | |
| CDistortParamKB4CostFunctor | |
| Cbindings.DPad | |
| Cdraw_state | One "frame" of draw state, what is passed to the variable tracking visitor functions, holds pointers to the program and live state such as visibility stack of gui headers |
| ►Cstd::enable_shared_from_this | |
| CContext | |
| Ceuroc_device | |
| Ceuroc_player_config | Configuration for the euroc player |
| Ceuroc_player_dataset_info | Describes information about a particular EuRoC dataset residing in path |
| Ceuroc_player_playback_config | Playback configuration for the euroc player |
| Ceuroc_recorder | |
| ►CException | |
| Cmonado.MonadoHeaderNotFoundError | |
| Cmonado.MonadoLibraryNotFoundError | |
| Cfake_timing | A very simple pacer that tries it best to pace a compositor |
| Cxrt::auxiliary::tracking::slam::feature_count_sample | |
| Cxrt::auxiliary::tracking::slam::TrackerSlam::Features::FeatureCounter | |
| Cxrt::auxiliary::tracking::slam::TrackerSlam::Features | Tracker feature tracking info |
| Cbindings.FeatureSet | |
| Cfence | A very simple implementation of a fence primitive |
| Cxrt::auxiliary::tracking::psmv::FindLowestScore< ValueType, FunctionType > | Helper struct that keeps the value that produces the lowest "score" as computed by your functor |
| Cxrt::tracking::hand::mercury::lm::FingerLimit | |
| Cflags | |
| Cformat_list_helper | |
| Cfov_entry | |
| Cframe | |
| Cxrt::auxiliary::tracking::FrameMat | This class implements the xrt_frame interface, allowing interfacing to cv::Mat from C code |
| Cxrt::auxiliary::util::detail::GenericCallbackEntry< CallbackType, MaskType > | Element type stored in GenericCallbacks, for internal use only |
| Cxrt::auxiliary::util::GenericCallbacks< CallbackType, EventBitflagType > | A generic collection of callbacks for event types represented as a bitmask, intended to be wrapped for each usage |
| Cxrt::auxiliary::util::GenericCallbacks< xrt_android_lifecycle_event_handler_t, enum xrt_android_lifecycle_event > | |
| Cgfx_layer_state | Internal state for the layer squashing render step, contains all per-view state |
| Cgfx_layer_view_state | Internal per-view for the layer squashing render step |
| Cgfx_mesh_data | |
| Cgfx_mesh_state | |
| Cgfx_mesh_view_data | |
| Cgroup | |
| Cgui_imgui | Internal gui state |
| Cgui_ogl_texture | A OpenGL texture |
| ►Cgui_program | A gui program |
| Csdl2_program | Common struct holding state for the GUI interface |
| Cgui_record_window | |
| ►Cgui_scene | A single currently running scene |
| Ccalibration_scene | An OpenCV-based camera calibration scene |
| Cdebug_scene | A GUI scene for debugging Monado while it is running, it uses the variable tracking code in the util/u_var.h file to provide live updates state |
| Cgui_remote | A GUI scene that lets the user select a user device |
| Cmain_menu | A main menu GUI scene allowing selection of which scene to proceed to |
| Cvideo_select | A GUI scene that lets the user select a user device |
| Cgui_scene_manager | |
| Cgui_tracking_overrides | |
| Cgui_widget_native_images | A small widget that interfaces a u_native_images_debug struct, caching the imports from the listed xrt_image_native list |
| Cgui_widget_native_images_record | A single record in a native image widget storage |
| Cgui_widget_native_images_storage | Helper struct to cache gui_widget_native_images |
| Cxrt::tracking::hand::mercury::Hand3D | |
| Cxrt::tracking::hand::mercury::hand_detection_run_info | |
| Cxrt::tracking::hand::mercury::hand_region_of_interest | |
| Cxrt::tracking::hand::mercury::hand_size_refinement | |
| Cipcproto.common.HandleType | |
| Cxrt::tracking::hand::mercury::lm::HandLimit | |
| Cxrt::tracking::hand::mercury::lm::HandStability | |
| Cxrt::tracking::hand::mercury::HandTracking | Main class of Mercury hand tracking |
| Cxrt::auxiliary::tracking::psvr::Helper | |
| Cxrt::auxiliary::tracking::HelperDebugSink | |
| Chg_tuneable_values | |
| Cxrt::auxiliary::util::HistoryBuffer< T, MaxSize > | Stores some number of values in a ring buffer, overwriting the earliest-pushed-remaining element if out of room |
| Cxrt::auxiliary::util::HistoryBuffer< Eigen::Array< float, 3, 21 >, 2 > | |
| Cxrt::auxiliary::util::HistoryBuffer< struct relation_history_entry, BufLen > | |
| Cxrt::auxiliary::util::HistoryBuffer< uint64_t, 2 > | |
| Chololens_sensors_packet | |
| Cht_async_impl | A synchronous to asynchronous wrapper around the hand-tracker code |
| Cht_device | |
| Cxrt::tracking::hand::mercury::ht_view | |
| Chydra_controller_state | |
| Chydra_state_machine | The details of the Hydra state machine in a convenient package |
| Cbindings.Identifier | |
| Cxrt::auxiliary::util::detail::identity< T > | |
| Cillixr_hmd | |
| Cillixr_prober | |
| Cimcontrol_buf | |
| Cimu_fusion | |
| Cindex_camera | A calibrated camera on an Index |
| CIndexFingerInput | |
| CInputClass | |
| Cxrt::auxiliary::math::detail::IntegerLowPassIIR< Value, Scalar > | The shared implementation (between vector and scalar versions) of an integer IIR/exponential low-pass filter |
| Cxrt::auxiliary::math::detail::IntegerLowPassIIR< int64_t, int64_t > | |
| Cxrt::auxiliary::math::detail::IntegerLowPassIIR< Scalar, Scalar > | |
| Cxrt::auxiliary::math::IntegerLowPassIIRFilter< Scalar > | A very simple integer low-pass filter, using a "one-pole infinite impulse response" design (one-pole IIR), also known as an exponential filter |
| Cxrt::auxiliary::math::IntegerLowPassIIRFilter< int64_t > | |
| Cipc_app_state | State for a connected application |
| Cipc_arg_swapchain_from_native | Arguments for creating swapchains from native images |
| Cipc_client_android | |
| Cipc_client_description | Initial info from a client when it connects |
| Cipc_client_list | |
| Cipc_client_space | |
| Cipc_client_space_overseer | |
| Cipc_client_state | Holds the state for a single client |
| Cipc_client_system_devices | |
| Cipc_connection | Connection |
| Cipc_device | |
| Cipc_info_get_view_poses_2 | Arguments for xrt_device::get_view_poses with two views |
| Cipc_layer_entry | Data for a single composition layer |
| Cipc_layer_slot | Render state for a single client, including all layers |
| Cipc_message_channel | Wrapper for a socket and flags |
| Cipc_server | Main IPC object for the server |
| Cipc_server_mainloop | Platform-specific mainloop object for the IPC server |
| Cipc_shared_binding_profile | A binding in the shared memory area |
| Cipc_shared_device | A device in the shared memory area |
| Cipc_shared_memory | A big struct that contains all data that is shared to a client, no pointers allowed in this |
| Cipc_shared_tracking_origin | A tracking in the shared memory area |
| Cipc_swapchain_data | Information about a single swapchain |
| Cipc_thread | |
| ►Cvr::IServerTrackedDeviceProvider | |
| CCServerDriver_Monado | |
| ►Cvr::ITrackedDeviceServerDriver | |
| CCDeviceDriver_Monado | |
| CCDeviceDriver_Monado_Controller | |
| ►Cvr::IVRDisplayComponent | |
| CCDeviceDriver_Monado | |
| ►Cvr::IVRDriverContext | |
| CContext | |
| ►Cvr::IVRDriverInput | |
| CContext | |
| ►Cvr::IVRDriverLog | |
| CContext | |
| ►Cvr::IVRDriverManager | |
| CDriverManager | |
| ►Cvr::IVRIOBuffer | |
| CIOBuffer | |
| ►Cvr::IVRProperties | |
| CContext | |
| ►Cvr::IVRResources | |
| CResources | |
| ►Cvr::IVRServerDriverHost | |
| CContext | |
| ►Cvr::IVRSettings | |
| CSettings | |
| ►Cvr::IVRWatchdogProvider | |
| CCWatchdogDriver_Monado | |
| Cxrt::auxiliary::util::json::JSONBuilder | Helper class for building cJSON trees through operator<< |
| Cxrt::auxiliary::util::json::JSONNode | A JSONNode wraps a cJSON object and presents useful functions for accessing the different properties of the json structure like operator[], isType() and asType() methods |
| Cxrt::compositor::client::KeyedMutexCollection | A collection of DXGIKeyedMutex objects, one for each swapchain image in a swapchain |
| Cxrt::tracking::hand::mercury::keypoint_estimation_run_info | |
| Cxrt::tracking::hand::mercury::lm::KinematicHandLM | |
| Clh_model | A lighthouse consisting of sensors |
| Clh_sensor | A single lighthouse senosor point and normal, in IMU space |
| Clighthouse_base | |
| Clighthouse_base_calibration | |
| Clighthouse_frame | |
| Clighthouse_ootx_report | |
| Clighthouse_pulse | |
| Clighthouse_rotor_calibration | |
| Clighthouse_sensor | |
| Clighthouse_system | |
| Clighthouse_watchman | |
| Cxrt::auxiliary::math::detail::LowPassIIR< Value, Scalar > | The shared implementation (between vector and scalar versions) of an IIR low-pass filter |
| Cxrt::auxiliary::math::detail::LowPassIIR< double, double > | |
| Cxrt::auxiliary::math::detail::LowPassIIR< float, float > | |
| Cxrt::auxiliary::math::detail::LowPassIIR< Scalar, Scalar > | |
| Cxrt::auxiliary::math::detail::LowPassIIR< Vector, double > | |
| Cxrt::auxiliary::math::detail::LowPassIIR< Vector, Scalar > | |
| Cxrt::auxiliary::math::LowPassIIRFilter< Scalar > | A very simple low-pass filter, using a "one-pole infinite impulse response" design (one-pole IIR) |
| Cxrt::auxiliary::math::LowPassIIRFilter< double > | |
| Cxrt::auxiliary::math::LowPassIIRFilter< float > | |
| Cxrt::auxiliary::math::LowPassIIRVectorFilter< Dim, Scalar > | A very simple low-pass filter, using a "one-pole infinite impulse response" design (one-pole IIR) |
| Cxrt::auxiliary::math::LowPassIIRVectorFilter< 3, double > | |
| Cm_clock_observation | |
| Cm_clock_windowed_skew_tracker | |
| Cm_ff_f64 | |
| Cm_ff_vec3_f32 | |
| Cm_filter_euro_f32 | One Euro filter for a single float measurement |
| Cm_filter_euro_quat | One Euro filter for a unit quaternion (used as 3D rotation) |
| Cm_filter_euro_vec2 | One Euro filter for a 2D float measurement |
| Cm_filter_euro_vec3 | One Euro filter for a 3D float measurement |
| Cm_filter_one_euro_base | Base data type for One Euro filter instances |
| Cm_imu_3dof | |
| Cm_imu_pre_filter | This is a common IMU pre-filter which takes raw 'ticks' from an IMU measurement and converts it into floats representing radians per second and meters per second^2 floats |
| Cm_imu_pre_filter_part | This is a common IMU pre-filter which takes raw 'ticks' from a 3 axis IMU measurement and converts it into degrees per secs and meters per second^2 floats |
| Cm_lowpass_float | |
| Cm_lowpass_integer | |
| Cm_permutator | |
| Cm_relation_history | |
| Cxrt::auxiliary::tracking::psvr::match_data | |
| Cxrt::auxiliary::tracking::psvr::match_model | |
| CMatrix4x4 | |
| ►Cflexkalman::MeasurementBase | |
| Cxrt::auxiliary::tracking::AbsolutePositionLeverArmMeasurement | For PS Move-like things, where there's a directly-computed absolute position that is not at the tracked body's origin |
| Cxrt::auxiliary::tracking::BiasedGyroMeasurement | |
| Cxrt::auxiliary::tracking::WorldDirectionMeasurement< State > | For things like accelerometers, which on some level measure the local vector of a world direction |
| Cmesh_params | |
| ►CMetaBase | |
| Cwrap::org::freedesktop::monado::auxiliary::ActivityLifecycleListener::Meta | Class metadata |
| Cwrap::org::freedesktop::monado::auxiliary::MonadoView::Meta | Class metadata |
| Cwrap::org::freedesktop::monado::ipc::Client::Meta | Class metadata |
| Cwrap::org::freedesktop::monado::ipc::IMonado::Meta | Class metadata |
| Cxrt::tracking::hand::mercury::lm::minmax | |
| Cmnd_pose | A pose composed of a position and orientation |
| Cmnd_root | |
| Cmock_compositor_swapchain | Mock implementation of xrt_swapchain_native |
| Cxrt::tracking::hand::mercury::model_input_wrap | |
| Cxrt::tracking::hand::mercury::model_output_visualizers | |
| Cxrt::auxiliary::tracking::psvr::model_vertex | |
| Cmonado.Monado | |
| CMonadoInputComponent | |
| Cmulti_device | |
| Cmulti_layer_entry | Data for a single composition layer |
| Cmulti_layer_slot | Render state for a single client, including all layers |
| Corg.freedesktop.monado.auxiliary.NativeCounterpart | Object that tracks the native counterpart object for a type |
| Cxrt::auxiliary::tracking::NormalizedCoordsCache | Provides cached, precomputed normalized image coordinates from original, distorted ones |
| Cns_3d_eye | Distortion information about an eye parsed from the configuration file |
| Cns_3d_values | |
| Cns_builder | |
| Cns_depthai_device | |
| Cns_optics_config | |
| Cns_t265 | |
| Cns_ultraleap_device | |
| Cnull_comp_frame | Tracking frame state |
| Cxrt::auxiliary::util::Obj | Object that has a series of tracked variables |
| ►CObjectWrapperBase | |
| Cwrap::org::freedesktop::monado::auxiliary::ActivityLifecycleListener | |
| Cwrap::org::freedesktop::monado::auxiliary::MonadoView | Wrapper for org.freedesktop.monado.auxiliary.MonadoView objects |
| Cwrap::org::freedesktop::monado::ipc::Client | Wrapper for org.freedesktop.monado.ipc.Client objects |
| Cwrap::org::freedesktop::monado::ipc::IMonado | Wrapper for org.freedesktop.monado.ipc.IMonado objects |
| Cogl_import_results | Results from a import, nicer then having to pass in multiple arrays |
| Coh_system | |
| Cxrt::tracking::hand::mercury::one_curl | |
| Cxrt::tracking::hand::mercury::one_frame_input | |
| Cxrt::tracking::hand::mercury::one_frame_one_view | |
| Cxrt::tracking::hand::mercury::onnx_wrap | |
| Copengloves_bt_device | |
| Copengloves_communication_device | Interface for a communication method |
| Copengloves_input | |
| Copengloves_input_button | |
| Copengloves_input_buttons | |
| Copengloves_input_gesture | |
| Copengloves_input_gestures | |
| Copengloves_input_joystick | |
| Copengloves_input_joysticks | |
| Copengloves_output | |
| Copengloves_output_force_feedback | |
| Copengloves_serial_device | |
| Copenhmd_values | |
| COpticalSystem | |
| Cxrt::tracking::hand::mercury::lm::OptimizerFinger< T > | |
| Cxrt::tracking::hand::mercury::lm::OptimizerFinger< HandScalar > | |
| Cxrt::tracking::hand::mercury::lm::OptimizerHand< T > | |
| Cxrt::tracking::hand::mercury::lm::OptimizerHand< HandScalar > | |
| Cxrt::tracking::hand::mercury::lm::OptimizerMetacarpalBone< T > | |
| Cxrt::tracking::hand::mercury::lm::OptimizerMetacarpalBone< HandScalar > | |
| Cxrt::tracking::hand::mercury::lm::OptimizerThumb< T > | |
| Cxrt::tracking::hand::mercury::lm::OptimizerThumb< HandScalar > | |
| Corientations54 | |
| Cxrt::tracking::hand::mercury::lm::Orientations54< T > | |
| ►Cos_ble_device | Representing a single ble notify attribute on a device |
| Cble_notify | An implementation of os_ble_device using a DBus connection to BlueZ |
| Cos_cond | A wrapper around a native conditional variable |
| ►Cos_hid_device | Representing a single hid interface on a device |
| Chid_hidraw | |
| Cos_mutex | A wrapper around a native mutex |
| Cos_precise_sleeper | |
| Cos_semaphore | A wrapper around a native semaphore |
| Cos_thread | A wrapper around a native thread |
| Cos_thread_helper | All in one helper that handles locking, waiting for change and starting a thread |
| Coxr_action_attachment | Data associated with an Action that has been attached to a Session |
| Coxr_action_cache | The set of inputs/outputs for a single sub-action path for an action |
| Coxr_action_input | A input action pair of a xrt_input and a xrt_device, along with the required transform |
| Coxr_action_output | A output action pair of a xrt_output_name and a xrt_device |
| Coxr_action_set_attachment | The data associated with the attachment of an Action Set (oxr_action_set) to as Session (oxr_session) |
| Coxr_action_state | The state of a action input |
| Coxr_binding | Interaction profile binding state |
| Coxr_debug_messenger | Debug object created by the client program |
| Coxr_dpad_binding_modification | Dpad binding extracted from XrInteractionProfileDpadBindingEXT |
| Coxr_dpad_emulation | Dpad emulation settings from oxr_interaction_profile |
| Coxr_dpad_entry | A entry in the dpad state for one action set |
| Coxr_dpad_settings | Dpad settings we need extracted from XrInteractionProfileDpadBindingEXT |
| Coxr_dpad_state | Holds dpad binding state for a single interaction profile |
| Coxr_event | |
| Coxr_extension_status | Structure tracking which extensions are enabled for a given instance |
| Coxr_frame_sync | Helper that handles synchronizing the xr{Wait,Begin,End}Frame calls |
| ►Coxr_handle_base | Used to hold diverse child handles and ensure orderly destruction |
| Coxr_action | A single action |
| Coxr_action_set | A group of actions |
| Coxr_hand_tracker | A hand tracker |
| Coxr_instance | Main object that ties everything together |
| Coxr_session | Object that client program interact with |
| Coxr_space | Can be one of several reference space types, or a space that is bound to an action |
| Coxr_swapchain | A set of images used for rendering |
| Coxr_input_transform | Variant type for input transforms |
| Coxr_input_transform_bool_to_vec1_data | Data required for INPUT_TRANSFORM_BOOL_TO_VEC1 |
| Coxr_input_transform_dpad_data | Data required for INPUT_TRANSFORM_DPAD |
| Coxr_input_transform_threshold_data | Data required for INPUT_TRANSFORM_THRESHOLD |
| Coxr_input_value_tagged | An input value enum with the associated tag required to interpret it |
| Coxr_interaction_profile | A single interaction profile |
| Coxr_logger | Logger struct that lives on the stack, one for each call client call |
| Coxr_path | Internal representation of a path, item follows this struct in memory and that in turn is followed by the string |
| Coxr_profiles_per_subaction | |
| ►Coxr_refcounted | |
| Coxr_action_ref | The reference-counted data of an action |
| Coxr_action_set_ref | The reference-counted data of an action set |
| Coxr_sink_logger | Allocate on the stack, make sure to zero initialize |
| Coxr_subaction_paths | A parsed equivalent of a list of sub-action paths |
| Coxr_system | Single or multiple devices grouped together to form a system that sessions can be created from |
| Cpacing_app | |
| Cpacing_compositor | |
| Cxrt::auxiliary::tracking::FrameMat::Params | Additional optional parameters for frame creation |
| CHmdDevice::Parts | |
| CPaths | This interface is missing in the C++ header but present in the C one, and the lighthouse driver requires it |
| Cbindings.PathsByLengthCollector | |
| Cplot_state | State for plotting m_ff_vec3_f32, assumes it's relative to now |
| ►Cplugin | |
| Cillixr_plugin | Simulated plugin class for an instance during phonebook registration |
| Cpool | |
| Cprober_hidraw | A hidraw interface that a prober_device exposes |
| Cprober_v4l | A v4l interface that a prober_device exposes |
| Cbindings.Profile | |
| Cprogram | |
| Cxrt::tracking::hand::mercury::projection_instructions | |
| Cxrt::tracking::hand::mercury::projection_state | |
| Cipcproto.common.Proto | |
| Cxrt::auxiliary::tracking::psvr::proximity_data | |
| Cpsmv_calibration_part | Part of a calibration data, multiple packets make up a single data packet |
| Cpsmv_calibration_zcm1 | Calibration data, multiple packets goes into this |
| Cpsmv_calibration_zcm2 | Calibration data, multiple packets goes into this |
| Cpsmv_f32_wire | Wire encoding of a single 32 bit float, "little" endian |
| Cpsmv_i16_wire | Wire encoding of a single 16 bit integer, little endian |
| Cpsmv_input_zcm1 | Input package for ZCM1 |
| Cpsmv_input_zcm2 | Input package for ZCM2 |
| Cpsmv_parsed_calibration_zcm1 | Parsed calibration data from a ZCM1 device |
| Cpsmv_parsed_calibration_zcm2 | Parsed calibration data from a ZCM2 device |
| Cpsmv_parsed_input | A parsed input packet |
| Cpsmv_parsed_sample | A parsed sample of accel and gyro |
| Cpsmv_set_led | Led setting packet |
| Cpsmv_u16_wire | Wire encoding of a single 16 bit integer, little endian |
| Cpsmv_vec3_f32_wire | Wire encoding of three 32 bit float, "little" endian |
| Cpsmv_vec3_i16_wire | Wire encoding of three 16 bit integers, little endian |
| Cpsmv_vec3_u16_wire | Wire encoding of three 16 bit integers, little endian |
| Cxrt::auxiliary::tracking::PSMVFusionInterface | |
| Cpssense_feature_report | HID output report data packet |
| Cpssense_i16_le | 16-bit little-endian int |
| Cpssense_i32_le | 32-bit little-endian int |
| Cpssense_input_report | HID input report data packet |
| Cpssense_input_state | PlayStation Sense state parsed from a data packet |
| Cpssense_output_report | HID output report data packet |
| Cpsvr_parsed_sample | A parsed single gyro, accel and tick sample |
| Cpsvr_parsed_sensor | Over the wire sensor packet from the headset |
| Cpsvr_parsed_status | A status packet from the headset in wire format |
| Cxrt::deleters::ptr_deleter< T, DeleterFn > | Deleter type for interfaces with destroy functions that take just pointers |
| Cxrt::deleters::ptr_ptr_deleter< T, DeleterFn > | Deleter type for interfaces with destroy functions that take pointers to interface pointers (so they may be zeroed) |
| Cxrt::tracking::hand::mercury::lm::Quat< Scalar > | |
| Cxrt::tracking::hand::mercury::lm::Quat< HandScalar > | |
| Cxrt::tracking::hand::mercury::lm::Quat< T > | |
| CQuaternion | |
| Cqwerty_system | Container of qwerty devices and driver properties |
| Cr_device | Device |
| Cr_head_data | |
| Cr_hmd | HMD |
| Cr_hub | Central object remote object |
| Cr_remote_connection | Shared connection |
| Cr_remote_controller_data | Data per controller |
| Cr_remote_data | Remote data sent from the debugger to the hub |
| Cxrt::auxiliary::util::RandomAccessIteratorBase< ContainerOrHelper > | Template for base class used by "random-access" iterators and const_iterators, providing all the functionality that is independent of element type and const-ness of the iterator |
| ►Cxrt::auxiliary::util::RandomAccessIteratorBase< const RingBufferHelper > | |
| Cxrt::auxiliary::util::detail::HistoryBufConstIterator< T, MaxSize > | Class template for const_iterator for HistoryBuffer |
| Cxrt::auxiliary::util::detail::HistoryBufIterator< T, MaxSize > | Class template for iterator for HistoryBuffer |
| Cxrt::auxiliary::math::Rational< Scalar > | A rational (fractional) number type |
| Cxrt::auxiliary::math::Rational< int64_t > | |
| CRay | |
| Crecord_scene | |
| Cxrt::deleters::reference_deleter< T, ReferenceFn > | Deleter type for ref-counted interfaces with two-parameter reference(dest, src) functions |
| Crelation_history_entry | |
| Cxrt::auxiliary::tracking::RemapPair | An x,y pair of matrices for the remap() function |
| Crender_buffer | Helper struct holding a buffer and its memory |
| Crender_compute | A compute rendering is used to create command buffers needed to do one frame of compositor rendering using compute shaders, it holds onto resources used by the command buffer |
| Crender_compute_blit_push_data | Push data that is sent to the blit shader |
| Crender_compute_distortion_ubo_data | UBO data that is sent to the compute distortion shaders |
| Crender_compute_layer_ubo_data | UBO data that is sent to the compute layer shaders |
| Crender_gfx | A rendering is used to create command buffers needed to do one frame of compositor rendering, it holds onto resources used by the command buffer |
| Crender_gfx_layer_cylinder_data | UBO data that is sent to the layer cylinder shader |
| Crender_gfx_layer_equirect2_data | UBO data that is sent to the layer equirect2 shader |
| Crender_gfx_layer_projection_data | UBO data that is sent to the layer projection shader |
| Crender_gfx_layer_quad_data | UBO data that is sent to the layer quad shader |
| Crender_gfx_mesh_ubo_data | UBO data that is sent to the mesh shaders |
| Crender_gfx_render_pass | A render pass while not depending on a VkFramebuffer does depend on the format of the target image(s), and other options for the render pass |
| Crender_gfx_target_resources | Each rendering (render_gfx) render to one or more targets (render_gfx_target_resources), the target points to one render pass and its pipelines (render_gfx_render_pass) |
| Crender_resources | Holds all pools and static resources for rendering |
| Crender_scratch_color_image | Small helper struct to hold a scratch image, intended to be used with the compute pipeline where both srgb and unorm views are needed |
| Crender_scratch_images | Helper struct to hold scratch images |
| Crender_shaders | Holds all shaders |
| Crender_sub_alloc | Per frame sub-allocation into a buffer, used to reduce the number of UBO objects we need to create |
| Crender_sub_alloc_tracker | A per-frame tracker of sub-allocation out of a buffer, used to reduce the number of UBO objects we need to create |
| Crender_viewport_data | The pure data information about a view that the renderer is rendering to |
| Cxrt::tracking::hand::mercury::lm::ResidualHelper< T > | |
| Cxrt::tracking::hand::mercury::lm::ResidualTracker< T > | |
| Crift_s_camera | Specifies whether the user wants to enable autoexposure from the start |
| Crift_s_camera_calibration | |
| Crift_s_camera_calibration_block | |
| Crift_s_camera_finder | |
| Crift_s_camera_report_t | |
| Crift_s_controller | |
| Crift_s_controller_capsense_block_t | |
| Crift_s_controller_config | |
| Crift_s_controller_imu_block_t | |
| Crift_s_controller_imu_calibration | |
| Crift_s_controller_info_block_t | |
| Crift_s_controller_joystick_block_t | |
| Crift_s_controller_maskbyte_block_t | |
| Crift_s_controller_raw_block_t | |
| Crift_s_controller_report_t | |
| Crift_s_controller_triggrip_block_t | |
| Crift_s_device_type_record_t | |
| Crift_s_devices_list_t | |
| Crift_s_fisheye62_distortion | |
| Crift_s_frame_data | |
| Crift_s_hmd | |
| Crift_s_hmd_config | |
| Crift_s_hmd_imu_sample_t | |
| Crift_s_hmd_radio_command_t | |
| Crift_s_hmd_radio_response_t | |
| Crift_s_hmd_report_t | |
| Crift_s_imu_calibration | |
| Crift_s_imu_config_info_t | |
| Crift_s_led | |
| Crift_s_lensing_model | |
| Crift_s_panel_info_t | |
| Crift_s_projection_pinhole | |
| Crift_s_radio_command | |
| Crift_s_radio_json_read_state | |
| Crift_s_radio_state | |
| Crift_s_system | |
| Crift_s_tracked_device | |
| Crift_s_tracker | |
| Cxrt::auxiliary::util::detail::RingBufferHelper | All the bookkeeping for adapting a fixed-size array to a ring buffer |
| Crokid_fusion | |
| Crokid_hmd | |
| Crokid_usb_packed_vec | |
| Crokid_usb_pkt_combined | |
| Crokid_usb_pkt_sensor | |
| Crs_container | Container to store and manage useful objects from the RealSense API |
| Csdl_comp_frame | Tracking frame state |
| Csdl_swapchain | Sub-class of comp_swapchain, used to do OpenGL rendering |
| CServer | An internal interface utilized by the lighthouse driver |
| Cxrt::auxiliary::util::SharedThreadGroup | Wrapper around u_worker_group, use TaskCollection to dispatch work |
| Cxrt::auxiliary::util::SharedThreadPool | Wrapper around u_worker_thread_pool |
| Cxrt::auxiliary::tracking::SimpleIMUFusion | A simple IMU fusion class |
| Csimula_builder | |
| Csimulated_device | |
| Cslam_device | |
| Corg.freedesktop.monado.android_common.VrModeStatus.Status | |
| Csteamvr_builder | |
| ►CSteamVRDriverControl | |
| CSteamVRDriverControlInput | |
| CSteamVRDriverControlOutput | |
| Cxrt::auxiliary::tracking::StereoCameraCalibrationWrapper | Essential stereo calibration data wrapped for C++ |
| Cxrt::tracking::hand::mercury::lm::StereographicObservation< T > | |
| Cxrt::auxiliary::tracking::StereoRectificationMaps | Rectification maps as well as transforms for a stereo camera |
| Cxrt::auxiliary::util::StringList | A collection of strings (const char *), like a list of extensions to enable |
| ►CIMonado.Stub | |
| Corg.freedesktop.monado.ipc.MonadoImpl | Java implementation of the IMonado IPC interface |
| Csvr_display_distortion_polynomial_values | |
| Csvr_hmd | |
| Csvr_one_display_distortion | |
| Csvr_two_displays_distortion | |
| Ct_calibration_params | |
| Ct_calibration_status | |
| Ct_camera_calibration | Essential calibration data for a single camera, or single lens/sensor of a stereo camera |
| Ct_camera_calibration_kb4_params | Parameters for T_DISTORTION_FISHEYE_KB4 |
| Ct_camera_calibration_kb4_params_float | Floating point parameters for T_DISTORTION_FISHEYE_KB4 |
| Ct_camera_calibration_rt14_params | Parameters for T_DISTORTION_OPENCV_RADTAN_14 |
| Ct_camera_calibration_rt5_params | Parameters for T_DISTORTION_OPENCV_RADTAN_5 |
| Ct_camera_calibration_rt8_params | Parameters for T_DISTORTION_OPENCV_RADTAN_8 |
| Ct_camera_calibration_rt8_params_float | Floating point parameters for T_DISTORTION_OPENCV_RT8, also including metric_radius |
| Ct_camera_calibration_wmr_params | Parameters for T_DISTORTION_WMR |
| Ct_camera_extra_info | Information about image boundaries and camera orientations for all the cameras used in a tracking system |
| Ct_camera_extra_info_one_view | Information about image boundary and camera orientation for one view |
| Ct_camera_model_params | Floating point calibration data for a single calibrated camera |
| Ct_convert_table | |
| Ct_hand_tracking_async | |
| Ct_hand_tracking_create_info | Creation info for the creation of a hand tracker |
| Ct_hand_tracking_sync | Synchronously processes frames and returns two hands |
| Ct_hsv_filter_color | |
| Ct_hsv_filter_large_table | |
| Ct_hsv_filter_optimized_table | |
| Ct_hsv_filter_params | Parameters for constructing an HSV filter |
| Ct_image_boundary_circle | Circular image boundary |
| Ct_imu_calibration | Combined IMU calibration data |
| Ct_inertial_calibration | Parameters for accelerometer and gyroscope calibration |
| Ct_slam_calibration | Calibration information necessary for SLAM tracking |
| Ct_slam_camera_calibration | Extension to camera calibration for SLAM tracking |
| Ct_slam_imu_calibration | Extension to IMU calibration for SLAM tracking |
| Ct_slam_tracker_config | SLAM tracker configuration |
| Ct_stereo_camera_calibration | Stereo camera calibration data to be given to trackers |
| Ct_vit_bundle | A bundle of VIT interface functions, used by the tracking interface loader |
| Ctan_angles_transforms | |
| CTargetPoint | |
| Ctask | |
| Cxrt::auxiliary::util::TaskCollection | Class to let users fall into a pit of success by being designed as a one shot dispatcher instance |
| Ctexture | Helper struct to make code easier to read |
| Cthread | |
| Ctime_state | Time-keeping state structure |
| Ctmp | |
| Cxrt::auxiliary::util::Tracker | Object that has a series of tracked variables |
| Cxrt::auxiliary::tracking::psvr::TrackerPSVR | Main PSVR tracking class |
| Ctracking_model | |
| Ctranslations55 | |
| Cxrt::tracking::hand::mercury::lm::Translations55< T > | |
| Cu_autoexpgain | Auto exposure and gain (AEG) adjustment algorithm state |
| Cu_builder | This helper struct makes it easier to implement the builder interface, but it also comes with a set of integration that may not be what all builders want |
| Cu_builder_roles_helper | This small helper struct is for u_builder_roles_helper_open_system, lets a builder focus on opening devices rather then dealing with Monado structs like xrt_system_devices and the like |
| Cu_builder_search_filter | A filter to match the against |
| Cu_builder_search_results | Results of a search of devices |
| Cu_cardboard_distortion | Both given and derived values needed for cardboard distortion |
| Cu_cardboard_distortion_arguments | These are the values that you need to supply to the distortion code to setup a u_cardboard_distortion properly |
| Cu_cardboard_distortion_values | Values to create a distortion mesh from cardboard values |
| Cu_config_json | |
| Cu_deque_timepoint_ns | |
| Cu_device_simple_info | Info to describe a very simple headset with diffractive lens optics |
| Cu_extents_2d | Info to describe 2D extents of a device's screen |
| Cu_finger_joint_set | A set of joints in a single finger |
| Cu_frame_times_widget | |
| Cu_hand_joint_default_set | The set of joints in the XR_HAND_JOINT_SET_DEFAULT_EXT |
| Cu_hand_sim_finger | |
| Cu_hand_sim_hand | |
| Cu_hand_sim_metacarpal | |
| Cu_hand_sim_thumb | |
| Cu_hand_tracking | Main struct drivers can use to implement hand and finger tracking |
| Cu_hand_tracking_curl_values | Values used for the XRT_HAND_TRACKING_MODEL_FINGERL_CURL model |
| Cu_hand_tracking_finger_value | |
| Cu_hand_tracking_values | |
| Cu_hashmap_int | A simple uint64_t key to a void pointer hashmap |
| Cu_hashset | Kind of bespoke hashset implementation, where the user is responsible for allocating and freeing the items themselves |
| Cu_hashset_item | A embeddable hashset item, note that the string directly follows the u_hashset_item |
| Cu_id_ringbuffer | |
| Cu_index_fifo | |
| Cu_joint_space_relation | A space relation of a single joint |
| Cu_live_stats_ns | Struct to do live statistic tracking and printing of nano-seconds values, used by amongst other the compositor pacing code |
| Cu_metrics_session_frame | |
| Cu_metrics_system_frame | |
| Cu_metrics_system_gpu_info | |
| Cu_metrics_system_present_info | |
| Cu_metrics_used | |
| Cu_native_images_debug | A struct for debugging one or more native images |
| Cu_ns_meshgrid_values | |
| Cu_ns_p2d_values | |
| Cu_pa_frame | |
| Cu_pacing_app | This application pacing helper is designed to schedule the rendering time of clients that submit frames to a compositor, which runs its own render loop that picks latest completed frames for that client |
| Cu_pacing_app_factory | Small helper that creates a app pacers, allows timing information to be collected and controlled to a central place |
| Cu_pacing_compositor | Compositor pacing helper interface |
| Cu_panotools_values | Values to create a distortion mesh from panotools values |
| Cu_pc_display_timing_config | Configuration for the "display-timing-aware" implementation of u_pacing_compositor |
| Cu_pp_delegate | Helper struct to hold a function pointer and data pointer |
| Cu_pp_sink_stack_only | Stack only pretty printer sink, no need to free, must be inited before use |
| Cu_process | |
| Cu_session_event | Struct used by u_session to queue up events |
| Cu_sink_debug | Allows more safely to debug sink inputs and outputs |
| Cu_sink_queue_elem | |
| Cu_sink_quirk_params | |
| Cu_space | Representing a single space, can be several ones |
| Cu_space_overseer | Default implementation of the xrt_space_overseer object |
| Cu_string_list | |
| Cu_swapchain_debug | Allows to debug image that is in GPU memory |
| Cu_system_devices | Helper struct to manage devices by implementing the xrt_system_devices |
| Cu_system_devices_static | Helper struct to manage devices by implementing the xrt_system_devices, this has only static device roles |
| Cu_system_session_pair | A pair of xrt_session and xrt_session_event_sink that has been registered to this system, used to multiplex events to all sessions |
| Cu_threading_stack | |
| Cu_tracked_imu_3dof | |
| Cu_var_button | Simple pushable button |
| Cu_var_combo | Combo box information |
| Cu_var_curve | A single curve on a plot |
| Cu_var_curve_point | A point on the curve, uses doubles like ImPlotPoint |
| Cu_var_curves | A collection of curves to be plotted |
| Cu_var_draggable_f32 | Draggable single precision float information |
| Cu_var_draggable_u16 | Draggable usingned 16-bit integer information |
| Cu_var_f32_arr | Used to plot an array for values |
| Cu_var_histogram_f32 | Histogram based on single precision bars |
| Cu_var_info | Struct that keeps all of the information about the variable, some of the UI state is kept on it |
| Cu_var_root_info | Struct containing the information about a root object |
| Cu_var_timing | Used to plot a graph of timing information |
| Cu_vector_float | |
| Cu_vector_int | |
| Cu_vive_values | Values to create a distortion mesh from Vive configuration values |
| Cu_worker_group | A worker group where you submit tasks to |
| Cu_worker_thread_pool | A worker pool, can shared between multiple groups worker pool |
| Culv2_device | |
| Culv5_device | |
| CUndistortCostFunctor | |
| Cv4l2_control_state | |
| Cv4l2_state_want | |
| Cxrt::auxiliary::util::Var | Simple container for the variable information |
| Cxrt::tracking::hand::mercury::lm::Vec2< Scalar > | |
| Cxrt::tracking::hand::mercury::lm::Vec2< HandScalar > | |
| Cxrt::tracking::hand::mercury::lm::Vec2< T > | |
| Cxrt::tracking::hand::mercury::vec2_5 | |
| Cxrt::tracking::hand::mercury::lm::Vec3< Scalar > | |
| Cxrt::tracking::hand::mercury::lm::Vec3< HandScalar > | |
| Cxrt::tracking::hand::mercury::lm::Vec3< T > | |
| CVector2 | |
| CVector3 | |
| CVector4 | |
| Cxrt::auxiliary::tracking::psmv::View | Single camera |
| Cxrt::auxiliary::tracking::psvr::View | |
| Cxrt::auxiliary::tracking::ViewRectification | Rectification, rotation, projection data for a single view in a stereo pair |
| Cxrt::auxiliary::tracking::ViewState | Current state for each view, one view for mono cameras, two for stereo |
| Cvive_config | Headset config |
| Cvive_config_read_report | |
| Cvive_config_start_report | |
| Cvive_controller_battery_sample | |
| Cvive_controller_button_report | |
| Cvive_controller_button_sample | |
| Cvive_controller_config | Controller config |
| Cvive_controller_haptic_pulse_report | |
| Cvive_controller_lighthouse_pulse | |
| Cvive_controller_lighthouse_pulse_report | |
| Cvive_controller_message | |
| Cvive_controller_poweroff_report | |
| Cvive_controller_report1 | |
| Cvive_controller_report2 | |
| Cvive_controller_touch_sample | |
| Cvive_controller_trigger_sample | |
| Cvive_firmware_version_report | |
| Cvive_headset_lighthouse_pulse | |
| Cvive_headset_lighthouse_pulse_report | |
| Cvive_headset_lighthouse_v2_pulse | |
| Cvive_headset_lighthouse_v2_pulse_raw_report | |
| Cvive_headset_lighthouse_v2_pulse_report | |
| Cvive_headset_mainboard_device_info_report | |
| Cvive_headset_power_report | |
| Cvive_imu_range_modes_report | |
| Cvive_imu_report | |
| Cvive_imu_sample | |
| Cvive_mainboard_status_report | |
| Cvive_tracking_status | Summary of the status of various trackers |
| Cvk_buffer | |
| Cvk_bundle | A bundle of Vulkan functions and objects, used by both Compositor and Compositor client code |
| Cvk_cmd_blit_image_info | Argument struct for vk_cmd_blit_image_locked |
| Cvk_cmd_blit_images_side_by_side_info | Argument struct for vk_cmd_blit_images_side_by_side_locked |
| Cvk_cmd_copy_image_info | Argument struct for vk_cmd_copy_image_locked |
| Cvk_cmd_first_mip_image | A similar struct to VkImageSubresourceRange and VkImageSubresourceLayers expect for this it's implied that it's only the first mip-level and only one array layer used for the operation |
| Cvk_cmd_pool | Small helper to manage lock around a command pool |
| Cvk_descriptor_pool_info | Arguments to vk_create_descriptor_pool function |
| Cvk_device_features | Used to enable device features as a argument vk_create_device |
| Cvk_display | Probed display |
| Cvk_image | |
| Cvk_image_collection | |
| Cvk_image_readback_to_xf | |
| Cvk_image_readback_to_xf_pool | |
| Cvk_surface_info | |
| Cwatchman_imu_sample | |
| Cwatchman_touch_force | |
| Cwmr_bt_controllers_search_results | Results from searching for host attached Bluetooth controllers |
| Cwmr_camera | |
| Cwmr_camera_active_cmd | |
| Cwmr_camera_config | |
| Cwmr_camera::wmr_camera_expgain | |
| Cwmr_camera_gain_cmd | |
| Cwmr_camera_open_config | |
| Cwmr_companion_search_results | Results from searching for a companion device |
| Cwmr_config_header | |
| Cwmr_controller_config | |
| ►Cwmr_controller_connection | A connection for communicating with the controller |
| Cwmr_bt_connection | A connection to a Bluetooth connected WMR Controller device |
| Cwmr_controller_fw_cmd | |
| Cwmr_controller_fw_cmd_response | |
| Cwmr_controller_hp | |
| Cwmr_controller_hp_input | |
| Cwmr_controller_og | |
| Cwmr_controller_og_input | |
| Cwmr_distortion_3K | |
| Cwmr_distortion_6KT | |
| Cwmr_distortion_eye_config | |
| Cwmr_headset_descriptor | |
| Cwmr_headset_search_results | Results from searching for a headset |
| Cwmr_hmd_config | |
| Cwmr_hmd_controller_connection | |
| Cwmr_hmd_distortion_params | |
| Cwmr_inertial_sensor_config | |
| Cwmr_inertial_sensors_config | |
| Cwmr_led_config | |
| Cwmr_sensor_transforms_config | |
| Cxreal_air_parsed_calibration | |
| Cxreal_air_parsed_control | A control packet from the glasses in wire format |
| Cxreal_air_parsed_sample | A parsed single gyroscope, accelerometer and magnetometer sample with their corresponding factors for conversion from raw data |
| Cxreal_air_parsed_sensor | Over the wire sensor packet from the glasses |
| Cxreal_air_parsed_sensor_control_data | Over the wire sensor control data packet from the glasses |
| Cxrt_api_requirements | A range of API versions supported |
| Cxrt_application_info | Non-process-specific information provided by the application at instance create time |
| ►Cxrt_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 |
| Candroid_prober | Android prober struct |
| Carduino_prober | Arduino prober struct |
| Cdaydream_prober | Daydream prober struct |
| Ceuroc_prober | |
| Coh_prober | |
| Cpsvr_prober | PSVR prober struct |
| Crs_prober | |
| Csample_auto_prober | |
| Csimulated_prober | |
| Cxrt_base_body_joint_set_meta | |
| Cxrt_begin_session_info | Begin Session information not known until clients have created an xrt-instance such as which extensions are enabled, view type, etc |
| Cxrt_binding_input_pair | A binding pair, going from a binding point to a device input |
| Cxrt_binding_output_pair | A binding pair, going from a binding point to a device output |
| Cxrt_binding_profile | A binding profile, has lists of binding pairs to goes from device in name to the device it hangs off on |
| Cxrt_body_joint_location_fb | |
| Cxrt_body_joint_set | |
| Cxrt_body_joint_set_fb | |
| Cxrt_body_skeleton | |
| Cxrt_body_skeleton_fb | |
| Cxrt_body_skeleton_joint_fb | |
| Cxrt_builder | Sets up a collection of devices and builds a system, a setter upper |
| Cxrt_builder_estimate | A estimate from a setter upper about how many devices they can open |
| Cxrt_colour_rgb_f32 | A 3 element colour with floating point channels |
| Cxrt_colour_rgb_u8 | A 3 element colour with 8 bits per channel |
| Cxrt_colour_rgba_f32 | A 4 element colour with floating point channels |
| Cxrt_colour_rgba_u8 | A 4 element colour with 8 bits per channel |
| ►Cxrt_compositor | Common compositor client interface/base |
| ►Cxrt_compositor_d3d11 | Base class for a D3D11 client compositor |
| Cclient_d3d11_compositor | Wraps the real compositor providing a D3D11 based interface |
| ►Cxrt_compositor_d3d12 | Base class for a D3D12 client compositor |
| Cclient_d3d12_compositor | Wraps the real compositor providing a D3D12 based interface |
| ►Cxrt_compositor_gl | Base class for an OpenGL (ES) client compositor |
| ►Cclient_gl_compositor | Wraps the real compositor providing a OpenGL based interface |
| Cclient_gl_win32_compositor | A client facing win32 OpenGL base compositor |
| Cclient_gl_xlib_compositor | A client facing xlib OpenGL base compositor |
| ►Cxrt_compositor_native | Main compositor server interface |
| ►Ccomp_base | A simple compositor base that handles a lot of things for you |
| Ccomp_compositor | Main compositor struct tying everything in the compositor together |
| Cnull_compositor | Main compositor struct tying everything in the compositor together |
| ►Csdl_compositor | Split out for convenience |
| ►Csdl_program | C base class for the SDL program |
| Csdl_program_plus | C++ version of the sdl_program struct, where you place C++ only things |
| Csdl_program_plus | C++ version of the sdl_program struct, where you place C++ only things |
| Cipc_client_compositor | Define to test the loopback allocator |
| Cmock_compositor | Mock implementation of a native compositor |
| Cmulti_compositor | A single compositor for feeding the layers from one session/app into the multi-client-capable system compositor |
| ►Cxrt_compositor_vk | Base class for a Vulkan client compositor |
| Cclient_vk_compositor | Wraps the real compositor providing a Vulkan based interface |
| Cxrt_compositor_fence | Compositor fence used for synchronization |
| Cxrt_compositor_info | Capabilities and information about the compositor and device together |
| ►Cxrt_compositor_semaphore | Compositor semaphore used for synchronization, needs to be as capable as a Vulkan pipeline semaphore |
| Cipc_client_compositor_semaphore | Client proxy for an xrt_compositor_semaphore implementation over IPC |
| ►Cxrt_compositor_swapchain | |
| Ccomp_semaphore | A simple implementation of the xrt_compositor_semaphore interface |
| Cxrt_d3d_requirements | Graphics usage requirements for D3D APIs |
| ►Cxrt_device | A single HMD or input device |
| ►CDevice | |
| CControllerDevice | |
| CHmdDevice | |
| Candroid_device | |
| Carduino_device | |
| Cdaydream_device | |
| Chdk_device | |
| Chydra_device | A Razer Hydra device, representing just a single controller |
| Cipc_client_xdev | An IPC client proxy for an xrt_device |
| Cns_hmd | Information about the whole North Star headset |
| Coh_device | |
| Copengloves_device | |
| Cpsmv_device | A single PlayStation Move Controller |
| Cpssense_device | A single PlayStation Sense Controller |
| Cpsvr_device | Private struct for the PSVR driver device |
| ►Cqwerty_device | Fake device that modifies its tracked pose through its methods |
| Cqwerty_controller | Supports input actions and can be attached to the HMD pose |
| Cqwerty_hmd | |
| Crs_ddev | Device-SLAM tracked RealSense device (T26X series) |
| Crs_hdev | Host-SLAM tracked RealSense device (any RealSense device with camera and IMU streams) |
| Csample_hmd | A sample HMD device |
| Csdl_program | C base class for the SDL program |
| Csimulated_hmd | A example HMD device |
| Csurvive_device | |
| Cvive_controller_device | A Vive Controller device, representing just a single controller |
| Cvive_device | |
| Cwmr_controller_base | Common base for all WMR controllers |
| Cwmr_hmd | |
| Cxreal_air_hmd | Private struct for the xreal_air device |
| Cxrt_facial_base_expression_set_htc | |
| Cxrt_facial_expression_set | |
| Cxrt_facial_expression_set2_fb | |
| Cxrt_facial_eye_expression_set_htc | |
| Cxrt_facial_lip_expression_set_htc | |
| Cxrt_fov | Describes a projection matrix fov |
| ►Cxrt_frame | Basic frame data structure - holds a pointer to buffer |
| Cv4l2_frame | |
| Cvf_frame | Frame wrapping a GstSample/GstBuffer |
| Cxrt_frame_context | Object used to track all sinks and frame producers in a graph |
| ►Cxrt_frame_node | A interface object used for destroying a frame graph |
| CDebugHSVFilter | An xrt_frame_sink that can be used to debug the behavior of t_hsv_filter |
| CDebugHSVPicker | An xrt_frame_sink that can be used to select HSV thresholds interactively |
| CDebugHSVViewer | An xrt_frame_sink related to debug viewing of HSV |
| Ceuroc_player | Euroc player is in charge of the playback of a particular dataset |
| Cgstreamer_pipeline | A pipeline from which you can create one or more gstreamer_sink from |
| Cgstreamer_sink | An xrt_frame_sink that uses appsrc |
| Cgui_ogl_sink | An xrt_frame_sink that shows sunk frames in the GUI |
| Crs_source | RealSense source of camera and IMU data |
| Ct_hsv_filter | An xrt_frame_sink that splits the input based on hue |
| Cu_imu_sink_force_monotonic | An xrt_imu_sink splitter |
| Cu_imu_sink_split | An xrt_imu_sink splitter |
| Cu_sink_combiner | An xrt_frame_sink combiner, frames pushed to the left and right side will be combined into one xrt_frame with format XRT_STEREO_FORMAT_SBS |
| Cu_sink_converter | An xrt_frame_sink that converts frames |
| Cu_sink_deinterleaver | An xrt_frame_sink that deinterleaves stereo frames |
| Cu_sink_force_genlock | An xrt_frame_sink that takes two frames in any order, and pushes downstream in left-right order once it has two frames that are close enough together |
| Cu_sink_queue | An xrt_frame_sink queue, any frames received will be pushed to the downstream consumer on the queue thread |
| Cu_sink_queue | An xrt_frame_sink queue, any frames received will be pushed to the downstream consumer on the queue thread |
| Cu_sink_quirk | An xrt_frame_sink that quirks frames |
| Cu_sink_split | An xrt_frame_sink splitter |
| Cu_sink_stereo_sbs_to_slam_sbs | An xrt_frame_sink splitter |
| Cv4l2_fs | A single open v4l2 capture device, starts its own thread and waits on it |
| Cvf_fs | A frame server operating on a video file |
| Cvive_source | Manages the data streaming state related to a vive headset |
| Cwmr_source | Handles all the data sources from the WMR driver |
| Cxrt::auxiliary::tracking::psmv::TrackerPSMV | The core object of the PS Move tracking setup |
| Cxrt::auxiliary::tracking::slam::TrackerSlam | Main implementation of xrt_tracked_slam |
| ►Cxrt_frame_sink | A object that is sent frames |
| CDebugHSVFilter | An xrt_frame_sink that can be used to debug the behavior of t_hsv_filter |
| CDebugHSVPicker | An xrt_frame_sink that can be used to select HSV thresholds interactively |
| CDebugHSVViewer | An xrt_frame_sink related to debug viewing of HSV |
| Cgstreamer_sink | An xrt_frame_sink that uses appsrc |
| Cgui_ogl_sink | An xrt_frame_sink that shows sunk frames in the GUI |
| Ct_hsv_filter | An xrt_frame_sink that splits the input based on hue |
| Cu_sink_combiner | An xrt_frame_sink combiner, frames pushed to the left and right side will be combined into one xrt_frame with format XRT_STEREO_FORMAT_SBS |
| Cu_sink_converter | An xrt_frame_sink that converts frames |
| Cu_sink_deinterleaver | An xrt_frame_sink that deinterleaves stereo frames |
| Cu_sink_force_genlock | An xrt_frame_sink that takes two frames in any order, and pushes downstream in left-right order once it has two frames that are close enough together |
| Cu_sink_queue | An xrt_frame_sink queue, any frames received will be pushed to the downstream consumer on the queue thread |
| Cu_sink_queue | An xrt_frame_sink queue, any frames received will be pushed to the downstream consumer on the queue thread |
| Cu_sink_quirk | An xrt_frame_sink that quirks frames |
| Cu_sink_split | An xrt_frame_sink splitter |
| Cu_sink_stereo_sbs_to_slam_sbs | An xrt_frame_sink splitter |
| Cxrt::auxiliary::tracking::psmv::TrackerPSMV | The core object of the PS Move tracking setup |
| Cxrt::auxiliary::tracking::slam::TrackerSlam | Main implementation of xrt_tracked_slam |
| ►Cxrt_fs | Frameserver that generates frames |
| Ceuroc_player | Euroc player is in charge of the playback of a particular dataset |
| Crs_source | RealSense source of camera and IMU data |
| Cv4l2_fs | A single open v4l2 capture device, starts its own thread and waits on it |
| Cvf_fs | A frame server operating on a video file |
| Cwmr_source | Handles all the data sources from the WMR driver |
| Cxrt_fs_capture_parameters | Controlling the camera capture parameters |
| ►Cxrt_fs_mode | |
| Cv4l2_source_descriptor | Descriptor of a v4l2 source |
| Cxrt_hand_joint_set | Joint set type used for hand tracking |
| Cxrt_hand_joint_value | Location of a single hand joint |
| Cxrt_hand_masks_sample | Masks (bounding boxes) of different hands from current views |
| Cxrt_hand_masks_sample::xrt_hand_masks_sample_camera | |
| Cxrt_hand_masks_sample::xrt_hand_masks_sample_camera::xrt_hand_masks_sample_hand | |
| Cxrt_hand_masks_sink | An object to push xrt_hand_masks_sample to |
| Cxrt_hmd_parts | All of the device components that deals with interfacing to a users head |
| Cxrt_image_native | A single image of a swapchain based on native buffer handles |
| Cxrt_image_native_allocator | Allocator for system native images, in general you do not need to free the images as they will be consumed by importing them to the graphics API |
| Cxrt_imu_sample | IMU Sample |
| ►Cxrt_imu_sink | An object to send IMU samples to |
| Cu_imu_sink_force_monotonic | An xrt_imu_sink splitter |
| Cu_imu_sink_split | An xrt_imu_sink splitter |
| Cxrt::auxiliary::tracking::slam::TrackerSlam | Main implementation of xrt_tracked_slam |
| Cxrt_input | A single named input, that sits on a xrt_device |
| Cxrt_input_value | A union of all input types |
| ►Cxrt_instance | This interface acts as a root object for Monado |
| Cipc_client_instance | |
| Csdl_program | C base class for the SDL program |
| Ct_instance | Main "real" instance implementation |
| Cxrt_instance_info | Information provided by the application at instance create time |
| Cxrt_layer_advanced_blend_data | Advanced blend provides explicit control over source and destination blend factors, with separate controls for color and alpha |
| Cxrt_layer_cube_data | All the pure data values associated with a cube layer |
| Cxrt_layer_cylinder_data | All the pure data values associated with a cylinder layer |
| Cxrt_layer_data | All the pure data values associated with a composition layer |
| Cxrt_layer_depth_data | All the pure data values associated with a depth information attached to a layer |
| Cxrt_layer_depth_test_data | |
| Cxrt_layer_equirect1_data | All the pure data values associated with a equirect1 layer |
| Cxrt_layer_equirect2_data | All the pure data values associated with a equirect2 layer |
| Cxrt_layer_frame_data | Per frame data for the layer submission calls, used in xrt_compositor::layer_begin |
| Cxrt_layer_passthrough_data | All the pure data values associated with a passthrough layer |
| Cxrt_layer_projection_data | All the pure data values associated with a projection layer |
| Cxrt_layer_projection_depth_data | All the pure data values associated with a projection layer with depth swapchain attached |
| Cxrt_layer_projection_view_data | All of the pure data values associated with a single view in a projection layer |
| Cxrt_layer_quad_data | All the pure data values associated with a quad layer |
| Cxrt_limited_unique_id | A limited unique id, it is only unique for the process it is in, so must not be used or synchronized across process boundaries |
| Cxrt_luid | To transport LUIDs between different APIs |
| Cxrt_matrix_2x2 | A tightly packed 2x2 matrix of floats |
| Cxrt_matrix_3x3 | A tightly packed 3x3 matrix of floats |
| Cxrt_matrix_3x3_f64 | A tightly packed 3x3 matrix of doubles |
| Cxrt_matrix_4x4 | A tightly packed 4x4 matrix of floats |
| Cxrt_matrix_4x4_f64 | A tightly packed 4x4 matrix of double |
| Cxrt_multi_compositor_control | Special functions to control multi session/clients |
| Cxrt_normalized_rect | Normalized image rectangle, coordinates and size in 0 |
| Cxrt_offset | Image offset |
| Cxrt_output | A single named output, that sits on a xrt_device |
| Cxrt_output_force_feedback | |
| Cxrt_output_value | A union of all output types |
| Cxrt_passthrough | |
| Cxrt_passthrough_create_info | Passthrough creation info |
| Cxrt_passthrough_layer | |
| Cxrt_passthrough_layer_create_info | Passthrough layer creation info |
| Cxrt_platform_info | |
| Cxrt_pose | A pose composed of a position and orientation |
| Cxrt_pose_sample | Pose sample |
| ►Cxrt_pose_sink | An object to send pairs of timestamps and poses to |
| Cxrt::auxiliary::tracking::slam::TrackerSlam | Main implementation of xrt_tracked_slam |
| ►Cxrt_prober | The main prober that probes and manages found but not opened HMD devices that are connected to the system |
| Cprober | |
| ►Cxrt_prober_device | A probed device, may or may not be opened |
| Cprober_device | A single device found by a prober |
| Cxrt_prober_entry | Entry for a single device |
| Cxrt_prober_entry_lists | Main root of all of the probing device |
| Cxrt_quat | A quaternion with single floats |
| Cxrt_rect | Image rectangle |
| Cxrt_rect_f32 | Image rectangle |
| Cxrt_reference | A base class for reference counted objects |
| Cxrt_relation_chain | A chain of space relations and their associated validity flags |
| ►Cxrt_session | The XRT representation of XrSession, this object does not have all of the functionality of a session, most are partitioned to the session level compositor object |
| Cipc_client_session | IPC client implementation of xrt_session |
| Cu_session | This is a helper struct that fully implements xrt_session object |
| Cxrt_session_event | Union of all session events, used to return multiple events through one call |
| Cxrt_session_event_display_refresh_rate_change | Display refresh rate of compositor changed event, type XRT_SESSION_EVENT_DISPLAY_REFRESH_RATE_CHANGE |
| Cxrt_session_event_loss_pending | Loss pending event, XRT_SESSION_EVENT_LOSS_PENDING |
| Cxrt_session_event_lost | Session lost event, type XRT_SESSION_EVENT_LOST |
| Cxrt_session_event_overlay | Primary session state changes event, type XRT_SESSION_EVENT_OVERLAY_CHANGE |
| Cxrt_session_event_passthrough_state_change | Passthrough state change event |
| Cxrt_session_event_perf_change | Performance metrics change event |
| Cxrt_session_event_reference_space_change_pending | Event that tells the application that the reference space has a pending change to it, maps to XrEventDataReferenceSpaceChangePending, type XRT_SESSION_EVENT_REFERENCE_SPACE_CHANGE_PENDING |
| Cxrt_session_event_sink | Used internally from producers of events to push events into session, some sinks might multiplex events to multiple sessions |
| Cxrt_session_event_state_change | Session state changes event, type XRT_SESSION_EVENT_STATE_CHANGE |
| Cxrt_session_event_visibility_mask_change | Visibility mask changed event |
| Cxrt_session_info | Session information, mostly overlay extension data |
| Cxrt_settings_tracking | Holding enough information to recreate a tracking pipeline |
| Cxrt_shmem_handle_t | Generic typedef for platform-specific shared memory handle |
| Cxrt_size | Image size |
| Cxrt_slam_sinks | Container of pointers to sinks that could be used for a SLAM system |
| Cxrt_space | A space very similar to a OpenXR XrSpace but not a full one-to-one mapping, but used to power XrSpace |
| Cxrt_space_overseer | Object that oversees and manages spaces, one created for each XR system |
| Cxrt_space_relation | A relation with two spaces, includes velocity and acceleration |
| Cxrt_sub_image | Specifies a sub-image in a layer |
| ►Cxrt_swapchain | Common swapchain interface/base |
| ►Cxrt_swapchain_d3d11 | Base class for a D3D11 client swapchain |
| Cclient_d3d11_swapchain | Wraps the real compositor swapchain providing a D3D11 based interface |
| ►Cxrt_swapchain_d3d12 | Base class for a D3D12 client swapchain |
| Cclient_d3d12_swapchain | Wraps the real compositor swapchain providing a D3D12 based interface |
| ►Cxrt_swapchain_gl | Base class for an OpenGL (ES) client swapchain |
| Cclient_gl_eglimage_swapchain | Wraps the real compositor swapchain providing a OpenGL based interface |
| Cclient_gl_memobj_swapchain | Wraps the real compositor swapchain providing a OpenGL based interface |
| Cclient_gl_swapchain | Wraps the real compositor swapchain providing a OpenGL based interface |
| ►Cxrt_swapchain_native | Base class for a swapchain that exposes a native buffer handle to be imported into a client API |
| Ccomp_swapchain | A swapchain that is almost a one to one mapping to a OpenXR swapchain |
| Cipc_client_swapchain | Client proxy for an xrt_swapchain_native implementation over IPC |
| ►Cxrt_swapchain_vk | Base class for a Vulkan client swapchain |
| Cclient_vk_swapchain | Wraps the real compositor swapchain providing a Vulkan based interface |
| Cxrt_swapchain_create_info | Swapchain creation info |
| Cxrt_swapchain_create_properties | Struct used to negotiate properties of a swapchain that is created outside of the compositor |
| ►Cxrt_system | A system is a collection of devices, policies and optionally a compositor that is organised into a chosive group that is usable by one user, most of the functionality of a system is exposed through other objects, this is the main object |
| Cipc_client_system | IPC client implementation of xrt_system |
| Cu_system | A helper to implement a xrt_system, takes care of multiplexing events to sessions |
| ►Cxrt_system_compositor | The system compositor handles composition for a system |
| Cmulti_system_compositor | The multi-client module (aka multi compositor) is system compositor that multiplexes access to a single xrt_compositor_native, merging layers from one or more client apps/sessions |
| Cxrt_system_compositor_info | Capabilities and information about the system compositor (and its wrapped native compositor, if any), and device together |
| ►Cxrt_system_devices | A collection of xrt_device, and an interface for identifying the roles they have been assigned |
| Csdl_program | C base class for the SDL program |
| Cxrt_system_properties | Properties provided by the system |
| Cxrt_system_roles | Data associating a device index (in xrt_system_devices::xdevs) with a given "role" for dynamic role switching |
| ►Cxrt_tracked_psmv | A single tracked PS Move controller, camera and ball are not synced |
| Cxrt::auxiliary::tracking::psmv::TrackerPSMV | The core object of the PS Move tracking setup |
| Cxrt_tracked_psvr | A tracked PSVR headset |
| ►Cxrt_tracked_slam | An adapter that wraps an external SLAM tracker to provide SLAM tracking |
| Cxrt::auxiliary::tracking::slam::TrackerSlam | Main implementation of xrt_tracked_slam |
| ►Cxrt_tracking_factory | Tracking factory |
| Cp_factory | |
| ►Cxrt_tracking_origin | A tracking system or device origin |
| CContext | |
| Chydra_system | A Razer Hydra system containing two controllers |
| Cp_factory | |
| Csurvive_system | |
| Cxrt_tracking_override | |
| Cxrt_tracking_sample | IMU Sample |
| Cxrt_uuid | To transport UUIDs between different APIs |
| Cxrt_uv_triplet | Represents a uv triplet for distortion, basically just three xrt_vec2 |
| Cxrt_vec1 | A 1 element vector with single floats |
| Cxrt_vec2 | A 2 element vector with single floats |
| Cxrt_vec2_i32 | A 2 element vector with 32 bit integers |
| Cxrt_vec3 | A 3 element vector with single floats |
| Cxrt_vec3_f64 | A 3 element vector with single doubles |
| Cxrt_vec3_i32 | A 3 element vector with 32 bit integers |
| Cxrt_view | A per-lens/display view information |
| Cxrt_visibility_mask | Visibility mask helper, the indices and vertices are tightly packed after this struct |
| ►CAppCompatActivity | |
| Corg.freedesktop.monado.android_common.AboutActivity | |
| ►CApplication | |
| Corg.freedesktop.monado.openxr_runtime.MonadoOpenXrApplication | Subclass required for Hilt usage |
| Cbool | |
| ►CFragment | |
| Corg.freedesktop.monado.android_common.VrModeStatus | A Fragment for displaying/affecting VR Listener status |
| CScalar | |
| ►CServiceConnection | |
| Corg.freedesktop.monado.ipc.Client | Provides the client-side code to initiate connection to Monado IPC service |
| Csize_t | |
| ►CSurfaceView | |
| Corg.freedesktop.monado.auxiliary.MonadoView | |
1.9.4