Poses in ILLIXR
Poses are one of the fundamental types of data used by ILLIXR. The pose represents the position (x, y, z) and orientation (a quaternion: w, x, y, z) of an object. ILLIXR can work with three different forms of the pose:
- ILLIXR internal format: API
- x, y, z are contained in an Eigen vector
- w, x, y, z are contained in an Eigen Quaternion
- This format is designed for performing direct computations on the components (e.g., shift, rotation)
- OpenXR format (XrPosef): API
- x, y, z are contained in a vector of three float values
- w, x, y, z are contained in a vector of four float values
- This format is designed for transport and compatability, with no inherent overheads
- Monado (xrt_pose): API
- x, y, z are contained in a vector of three float values
- w, x, y, z are contained in a vector of four float values
- This format is bit-identical in structure to the OpenXR format, but the compiler sees it as a distinct type, so formal copy/conversion is necessary between the two
Pose Types
Head Pose
Head Pose Data
The head_pose_data struct is specific to ILLIXR's internal hand tracking and will be retired in the near future.
Head Pose Type
The head_pose_type is used to convey both the pose and related velocity information (linear and angular); along with validity flags. OpenXR itself does not have a single structure that encapsulates all of this data, so we adopt the Monado xrt_space_relation struct for this purpose. So that Monado is not required just for this struct, we have our own (structurally equivalent) definition in openxr_defines.hpp.
Fast Head Pose Type
The fast_head_pose_type is designed to be used as the output of pose prediction. In addition to the a head_pose_type it carries members for predicted pose time and the computed time. This is the only serializable form of the head pose, enabling it to be sent over a network.
Hand Poses
The hand pose structs carry information about the 26 points used to describe the position of each hand and fingers.
Hand Joint Pose
The hand_joint_pose contains the pose, velocities (linear and angular), and validity flags for a single joint of the hand. For Monado we adopt the xrt_hand_joint_value; for OpenXR this is a structurally equivalent extension of the xrt_space_relation struct with a joint radius float.
Hand Joint Poses
The hand_joint_poses structure holds the hand_joint_pose instances for all joints of a single hand along with a flag indicating if the hand was detected. For Monado we use the xrt_hand_joint_set, while for OpenXR we use the structurally equivalent hand_joint_poses.
Hand Joint Poses Pair
The hand_joint_poses_pair structure holds a map of the hands (RIGHT and LEFT) to their respective hand_joint_poses data, along with a timestamp to indicate the time the poses were acquired. This is the only serializable form of the hand poses, enabling it to be sent over a network. The OpenXR and Monado versions are identical.
Palm Poses
The palm pose structs hold information pertaining to the position, orientation, and movement of the palm.
Palm Pose
The palm_pose struct inherits from the xrt_space_relation and adding a function to determine if the data it contains are valid.
Palm Poses Pair
The palm_poses_pair struct holds a mapping of hand (RIGHT or LEFT) to its associated palm_pose data and a time_point for the timestamp of the data. The Openxr and Monado versions are structurally equivalent. This is the only serializable form for of the palm pose, enabling it to be sent over a network.
Hand Interactions
Hand interactions carry information about basic hand gestures: poke, grab, aim, and pinch.
Hand Interaction Pose
The hand_interaction_pose struct contains data about whether a given hand interaction is being performed, where it is being performed, and whether the runtime considers the gesture to be active. The struct inherits from xrt_space_relation. The OpenXR and Monado versions are structurally equivalent.
Hand Interaction Poses
The hand_interaction_poses structure maps the pose type (AIM, GRIP, PINCH, POKE) to their hand_interaction_pose data. The OpenXR and Monado versions are structurally equivalent.
Hand Interation Poses Pair
The hand_interaction_poses_pair structure maps the hand interactions to specific hands (LEFT and RIGHT). It is the only serializable version of the hand interactions, enabling it to be sent over a network.
Combined Pose
The combined_pose structure encapsulates all pose information (head, hand, hand interactions, palm) from a specific instance in time. It also holds some network latency information to enable better pose prediction on the server. It is designed to carry off of this information over a network.