Body Tracking for Movement SDK for Unity

1. Make sure you have an OVRCameraRig prefab in your scene, which can be added with the building block.
2. From the OVRCameraRig object, navigate to the OVRManager component.
3. Select Target Devices.
4. Scroll down to Quest Features > General.
5. If you want hand tracking, select Controllers and Hands for Hand Tracking Support.
6. Under General, make sure Body Tracking Support is selected. Click General if that view isn’t showing.
   • If you want to use Inside-Out Body Tracking (IOBT), select High for Body Tracking Fidelity in the Movement Tracking section. IOBT is a suggested fidelity mode and not a requirement of the API. For more details, see Troubleshooting body tracking.
   • If you want to use Full Body, select Full Body for the Body Tracking Joint Set in the Movement Tracking section.
7. If you want Eye and Face Tracking, apply the same setting as in the previous steps.
   Note: OVRManager has a permissions request on startup that must be selected for the tracking technologies you require.
8. If your project depends on Face Tracking, Eye Tracking, or Hand Tracking, ensure that these are enabled on your HMD. This is typically part of the device setup, but you can verify or change the settings in Settings > Movement Tracking.
9. In the Unity Editor, go to Meta > Tools > Project Setup Tool to access the Project Setup Tool.
10. Select your platform.
11. Select Fix All if there are any issues. For details, see Use Project Setup Tool.

1. Be able to retarget body tracking to a character model,
2. Be able to adjust the character’s retargeted output.

1. Import the custom character into the Unity Project as an asset.
2. Right-click on the third-party model asset (target rig), and then select the Movement SDK > Body Tracking -> Open Retargeting Configuration Editor quick-action.
3. If a menu appears asking you to create a missing config JSON, select Create and pick a location for it.
4. The tool will automatically find a set of known joints which should exist on most characters, as well as a list of bone transforms on the character. Since known transforms are used for retargeting, please verify the transforms identified and make changes as necessary. Pose the character to T-Pose manually or by clicking Pose character to T-Pose and then clicking on Next. Save updates to the configuration when prompted.
5. The next screen will allow you to align the character to the smallest known source size known as a Min T-Pose. This will allow you to modify the configuration for shorter heights. Clicking Align with Skeleton will automatically align the character, while Reset T-Pose resets it to its original rest pose.
6. Click on the Preview Sequences buttons to see how the character retargets against the minimum T-pose. The improving the retargeted character’s appearance section explains how to tweak this result. When finished, click Next and save updates to the configuration as needed.
7. The next screen will allow you to align the character to the largest known source size known as a Max T-Pose. Use the alignment buttons as discussed previously for the Min T-Pose and preview the result using the Preview Sequences buttons. Click Next when finished.
8. The last Review & Export screen will allow you to see how the character scales between the minimum and maximum using the Size slider, and also preview the scale using the sequences buttons. When you are finished, click on Validate and save config.
9. (Optional) Unity uses a mesh’s precomputed bounds to determine visibility relative to a camera, and skinned meshes that are not considered visible will not be skinned. Therefore, if the mesh’s bounds are too small relative to an expected height or wingspan, it might not animate properly depending on how visible the bounds are. You may use the “Edit Bounds” button in a Skinned Mesh Renderer and make the bounds larger to mitigate this problem. For instance, you can increase the depth of the bounds of the character rendered below to accommodate the case where the user might reach forward and exceed the depth of the bounds. Additionally, you may enable “Update When Offscreen” option so that Unity recalculates the bounds every frame, however that will consume extra CPU cycles.
   

1. Drag the model or prefab of your character into the scene.
2. Right click on the model, then select Movement SDK > Body Tracking > Add Character Retargeter.
   • Alternatively, add the CharacterRetargeter component and the OVRBody component to the character manually.
3. The following options should be verified in the components added in the previous step:
   • For Generative Legs, make sure the character’s Provided Skeleton Type is set to Full Body in OVRBody (added in the previous step). Furthermore, OVRManager’s Body Tracking Joint Set must be set to Full Body in the Movement Tracking section for full body joints to be represented in any character. For IOBT, ensure that Body Tracking Fidelity is set to High in OVRManager’s Movement Tracking section. IOBT is a suggested fidelity mode and not a requirement of the API – for more details see Troubleshooting Body Tracking.

• Body tracking does not align with the retargeted mesh,
• The proportions of the character rig does not align with typical human proportions,
• The person being tracked has significantly different proportions than the character (for example, broader shoulders).

• TwistProcessor - This processor applies twist to the character’s joints. It is useful for fixing candy wrapping around wrists and twist related issues.
• ISDKProcessor - This processor applies ISDK to the character. It is useful for applying ISDK poses to the character.
• AnimationProcessor - This processor blends animation to the character. It is useful for blending animations and body tracking on the character.
• LocomotionProcessor - This processor applies locomotion to the character. It is useful for driving locomotion on a character and blending it with body tracking.
• CCDIKProcessor - This processor applies CCDIK to the character. It is useful for solving a bone chain to reach a target (for example, change the target hand position to a custom hand pose).

Fix candy wrapping around wrists

1. Fill Left/Right Arm Indices
2. Estimate Twist Axis

1. Configuration Setup - In this step, you can define the character’s T-Pose, the joints that should be retargeted, and the known joints to be mapped.
   • Configuration Joints:
     • In this list, you can remove any bones that shouldn’t be used for retargeting. This includes body parts that have a custom animation or IK purpose.
   • Known Joints:
     • The retargeting editor will best approximate which joints correspond to each known joint (for example, Right_UpperLeg -> Right Upper Leg). These are used for automatic alignment tooling purposes, and should be modified if they look incorrect.
   • Editor Visualization:
     • The retargeting editor is integrated with Unity’s transform editor tooling; the character skeleton will be rendered in editor. In this step, the character should be in T-Pose. If it isn’t, use the Pose character to T-Pose button, or manually align the character into a T-pose using Unity’s built-in transform tooling to move the skeleton bones.
2. Min/Max T-Pose Alignment - In this step, you can define the alignment between the source (body tracking) T-Pose and the target (character) T-Pose. This alignment and mapping is the data that drives the retargeting logic.
   • Editor Visualization:
     • In this step, the character visualization allows previewing of what the retargeting result will look like. This can be done simply by clicking on one of the preview sequences to visualize the result.
     • To adjust the result (for example, to bring the character backward), just edit the T-Pose alignment using Unity’s built-in transform tooling and the retargeted character preview will be updated immediately.
     • Adjust the alignment as much as you’d like so that retargeting looks visually appropriate.
3. Review & Export - In this step, you can preview the result of the min and max T-Pose alignment with different sizes or different proportions.

1. Understand that body tracking is compatible with keyframe animations.
2. Be able to apply this knowledge to import a key frame animation and apply the animation to the entire rig or only part of the rig (for example, the legs).

1. Download or create the animation that you want to add.
2. Ensure your character has an animator component with an assigned avatar as mentioned in Enable Prefab for Tracking.
3. Add an Animator Controller that will control when to play the animation and assign it to the Animator’s Controller field. In the example scene, this is in WaveAnimController.
4. Add a target processor on the CharacterRetargeter component, and set the type to Animation.
5. Define the mask that should be used for the animation blending on the newly added processor.
   • Anim Blend Indices: Define the joints that should be used to blend the animation. In our example, since the character is waving its arm, the Right_UpperArm/Right_LowerArm/Right_Hand joints are added to this mask.

1. Understand the need for controller-based animation vs body tracking.
2. Be able to implement a locomotion controller to allow controller-based animation in conjunction with body tracking

• Placement of colliders so that ground and object interactions work well.
• Implementing the PlayerController to locomote correctly in the virtual world and keep the camera aligned with the 1P view.
• Determining when to allow body tracking to override the controller-driven animations.

1. Integrate ISDK Locomotion in your scene.
2. Add the Locomotion processor and Animation processor in the list of target processors on a retargeted character.
3. Press the Setup button on the Locomotion processor
4. Press the Update anim blend indices with lower body button on the Animation processor.
5. Add an animator controller with a locomotion animation blend tree.

1. Understand the benefits of the AI Motion Synthesizer.
2. Be able to implement the AI Motion Synthesizer into their project.
3. Be able to utilize the AI Motion Synthesizer to provide realistic standing body movement for seated players.

• Improving animation fidelity
• Offering an efficient and lightweight alternative to traditional animation controllers
• Eliminating the need for additional animation assets for locomotion, such as generic animations for walking, running, and turning

1. Complete character setup in Set up a character for body tracking.
2. Enable the “Enable AI Motion Synthesizer” option on the MetaSourceDataProvider.cs component.
3. Add the AI Motion Synthesizer Joystick Input component to the character. Alternatively, you can add a custom input provider by implementing IAIMotionSynthesizerInputProvider. Set default speed, input bindings, and other parameters on the custom input provider.
4. To enable seated mode, enable the Enable Synthesized Standing Pose option on the MetaSourceDataProvider.cs component. This embodies the character as standing and uses their user-accurate proportions regardless of the body-tracked pose.
5. The character is ready to be driven by the blended pose of the AI Motion Synthesizer and Full Body Tracking.
   

• Visualize body poses in the Unity Editor
• View body poses at runtime
• Export body poses during Unity Preview
• Import body poses
• View how closely two body poses are aligned
• Set up custom actions to invoke based on comparisons
• Adjust body poses with the Editor

1. Create a body pose in the editor with a new GameObject that has a BodyPoseController component. Name it “BodyPose.”

1. Add BodyPoseBoneTransforms component to “BodyPose”.
2. In the Inspector, select Refresh Transforms.

1. Add a SkeletalDrawContainer component to the “BodyPose” object.
2. Assign the BodyPoseBoneTransforms that you added earlier to the “Body Pose Transforms” field of the SkeletalDrawContainer.
3. Assign body tracking data asset, such as the one from Packages/Meta XR Movement SDK/Runtime/Native/Data/OVRSkeletonRetargetingData.asset to SkeletalDrawContainer’s “Body Data” field.
4. Press play to visualize the skeleton. Change the “Thickness” or “Default Color” fields to adjust the look of the rendered skeleton. Note: these visuals do not currently run in Edit mode.

1. Add the OVRBodyPose component to the “BodyPose” object. This component reads body tracking data from the headset and converts it for BodyPoseController. OVRBodyPose is set to Full Body by default, but can also be set to Upper Body only (no legs).
   
   • Note: Different Quest devices may read body tracked data differently. For example, Quest 3 may automatically augment Full Body body tracking data with Inside Out Body Tracking (IOBT), which is not a feature available for Quest 2.
2. Drag the OVRBodyPose to the BodyPoseController → Source Data Object field.
   
   • This enables body tracking to drive the bone Poses at runtime or during the Unity preview when using Link. BodyPoseController’s “Export Asset” button works during Unity’s Preview mode. This means body poses can be exported from real body-tracked data from OVRBodyPose.
3. Select the “BodyPose” object, and then start a Unity preview by pressing the play button, with a headset plugged in and connected to Link. Use BodyPoseController’s “Export Asset” button to export the current bone pose. The exported data appears in a time-stamped generated asset file in the /Assets/BodyPoses/ folder.
   
   • Note: “Export Asset” is a Unity Editor function that is not accessible in an APK at runtime. Body poses can be exported during Unity Preview, not APK runtime.
   • It’s recommended that you change the default time-stamped name of the body pose asset to something describing the pose.
   • For body tracking to work over Link, your Meta Horizon Link application needs to have Developer Runtime Features enabled. This can be verified by checking Settings → Beta → Developer Runtime Features. Additional toggles in that user interface may be required for other Quest features to work properly over Link.
   

1. In the Unity Editor (not during a preview), drag a generated body pose asset file into the Source Data Object field of BodyPoseController. Click “Refresh T-Pose” and then “Refresh Source Data” to see the skeleton swap between the two poses.

- Source Data Object can be filled by any IBodyPose object. That means a BodyPoseController can reference data from another BodyPoseController (to duplicate a pose), or a BodyPoseBoneTransforms (though this is not recommended), or OVRBodyPose.

1. Add a BodyPoseAlignmentDetector component to “BodyPose.”
2. For the Pose A field, drag and drop a generated body pose file from the /Assets/BodyPoses/ folder. For Pose B, drag and drop this object itself, and select the BodyPoseController component in the disambiguation popup.
3. Drag and drop the BodyPose object into “Bone Visuals To Color”; this will cause the skeleton visuals to be recolored based on how closely the bone poses match.
4. Drag and drop the BodyPose object into “Skeletal Draw Containers”; this will cause the skeleton visuals to be re-colored based on how closely the bone poses match.

- The BodyTrackingForFitness scene is a proof of concept for an app that counts exercise poses using this BodyPoseAlignmentDetector. This app can be used, for example, to detect if the user is in a squat or not.

- `OnCompliance` triggers once each time all the bone poses comply.
- `OnDeficiency` triggers once each time at least one bone no longer complies.
- `OnCompliantBoneCount` triggers once each time the number of complying bones changes.

- The `Maximum Angle Delta` field determines how closely two bones need to align to count as compliant.
- The `Width` field determines how much margin there is between compliant and deficient. For example, if the `Left Arm Upper` must be 30 degrees aligned with a width of 4 degrees, then compliance will trigger when the `Left Upper Arm` is aligned within 28 degrees, and fall out of compliance when it exceeds 32 degrees. This overlap prevents flickering compliance.

- **Joint Rotation**: compares the local rotation, including the roll of the bone. This alignment detection is mathematically quite simple, but has the drawback of requiring bones to be perfectly rolled in addition to being perfectly angled.

- **Bone Direction**: compares the direction of the bone from the perspective of a specific bone. This method ignores bone roll, requiring a specific bone to be chosen as the arbiter of direction. This method of comparing angles felt better while testing for specific fitness application use cases, but it requires slightly more processing to test.

• Understand when the calibration API might be useful.
• Be able to apply the calibration API override the auto-detected height with an explicit height.

• How to check for common project-related errors
• How to tell if the tracking services are running
• Some of the most common symptoms and their causes

SERVICE com.oculus.bodyapiservice/.BodyApiService 98564e0 pid=17192 user=0
Client:
Begin_BodyApiService
{
"fbs" : true,
"iobt" : false,
"num_updates_counter" : 26693,
"usingEngineV1" : false
}
End_BodyApiService

• The fbs line indicates if Generative Legs are active.
• The IOBT line shows whether IOBT is active.

1. Check if hand tracking permissions are enabled for the device in Settings > Movement Tracking > Hand Tracking.
2. Ensure that Hand Tracking and Controllers are enabled in your project config.
3. Ensure that the app requests Hand Tracking on start-up.

1. Ensure you are connected with a USB cable that supports data. This can be tested from the Oculus App on the PC under Device Settings: Link Cable > Connect Your Headset > Continue.
2. Ensure you have Developer Runtime features enabled on the Oculus App on the PC by going to Settings > Beta > Developer Runtime Features.

• xrCreateBodyTrackerFB - Creates the body tracker.
• xrGetBodySkeletonFB - Gets the set of joints in a reference T-shaped pose.
• xrLocateBodyJointsFB - Gets the current location of joints.
• xrDestroyBodyTrackerFB - Destroys the tracker.

XrBodyTrackerCreateInfoFB
createInfo{XR_TYPE_BODY_TRACKER_CREATE_INFO_FB};
createInfo.bodyJointSet = XR_BODY_JOINT_SET_FULL_BODY_META;
XrBodyTrackerFB bodyTracker;
xrCreateBodyTrackerFB(session, &createInfo, &bodyTracker));

typedef enum XrFullBodyJointMETA{
XR_FULL_BODY_JOINT_ROOT_META = 0,
XR_FULL_BODY_JOINT_HIPS_META = 1,
XR_FULL_BODY_JOINT_SPINE_LOWER_META = 2,
XR_FULL_BODY_JOINT_SPINE_MIDDLE_META = 3,
XR_FULL_BODY_JOINT_SPINE_UPPER_META = 4,
XR_FULL_BODY_JOINT_CHEST_META = 5,
XR_FULL_BODY_JOINT_NECK_META = 6,
XR_FULL_BODY_JOINT_HEAD_META = 7,
XR_FULL_BODY_JOINT_LEFT_SHOULDER_META = 8,
XR_FULL_BODY_JOINT_LEFT_SCAPULA_META = 9,
XR_FULL_BODY_JOINT_LEFT_ARM_UPPER_META = 10,
XR_FULL_BODY_JOINT_LEFT_ARM_LOWER_META = 11,
XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_TWIST_META = 12,
XR_FULL_BODY_JOINT_RIGHT_SHOULDER_META = 13,
XR_FULL_BODY_JOINT_RIGHT_SCAPULA_META = 14,
XR_FULL_BODY_JOINT_RIGHT_ARM_UPPER_META = 15,
XR_FULL_BODY_JOINT_RIGHT_ARM_LOWER_META = 16,
XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_META = 17,
XR_FULL_BODY_JOINT_LEFT_HAND_PALM_META = 18,
XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_META = 19,
XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_META = 20,
XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_META = 21,
XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_META = 22,
XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_TIP_META = 23,
XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_META = 24,
XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_META = 25,
XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_META = 26,
XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_META = 27,
XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_TIP_META = 28,
XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_META = 29,
XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_META = 30,
XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_META = 31,
XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_META = 32,
XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_META = 33,
XR_FULL_BODY_JOINT_LEFT_HAND_RING_METACARPAL_META = 34,
XR_FULL_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_META = 35,
XR_FULL_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_META = 36,
XR_FULL_BODY_JOINT_LEFT_HAND_RING_DISTAL_META = 37,
XR_FULL_BODY_JOINT_LEFT_HAND_RING_TIP_META = 38,
XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_META = 39,
XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_META = 40,
XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_META = 41,
XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_META = 42,
XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_TIP_META = 43,
XR_FULL_BODY_JOINT_RIGHT_HAND_PALM_META = 44,
XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_META = 45,
XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_META = 46,
XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_META = 47,
XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_META = 48,
XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_TIP_META = 49,
XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_META = 50,
XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_META = 51,
XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_META = 52,
XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_META = 53,
XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_TIP_META = 54,
XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_META = 55,
XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_META = 56,
XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_META = 57,
XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_META = 58,
XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_META = 59,
XR_FULL_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_META = 60,
XR_FULL_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_META = 61,
XR_FULL_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_META = 62,
XR_FULL_BODY_JOINT_RIGHT_HAND_RING_DISTAL_META = 63,
XR_FULL_BODY_JOINT_RIGHT_HAND_RING_TIP_META = 64,
XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_META = 65,
XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_META = 66,
XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_META = 67,
XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_META = 68,
XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_META = 69,




// Lower body joints:
XR_FULL_BODY_JOINT_LEFT_UPPER_LEG_META = 70,
XR_FULL_BODY_JOINT_LEFT_LOWER_LEG_META = 71,
XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_TWIST_META = 72,
XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_META = 73,
XR_FULL_BODY_JOINT_LEFT_FOOT_SUBTALAR_META = 74,
XR_FULL_BODY_JOINT_LEFT_FOOT_TRANSVERSE_META = 75,
XR_FULL_BODY_JOINT_LEFT_FOOT_BALL_META = 76,




XR_FULL_BODY_JOINT_RIGHT_UPPER_LEG_META = 77,
XR_FULL_BODY_JOINT_RIGHT_LOWER_LEG_META = 78,
XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_TWIST_META = 79,
XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_META = 80,
XR_FULL_BODY_JOINT_RIGHT_FOOT_SUBTALAR_META = 81,
XR_FULL_BODY_JOINT_RIGHT_FOOT_TRANSVERSE_META = 82,
XR_FULL_BODY_JOINT_RIGHT_FOOT_BALL_META = 83,




XR_FULL_BODY_JOINT_COUNT_META = 84,




XR_FULL_BODY_JOINT_NONE_META = 85,
XR_FULL_BODY_JOINT_MAX_ENUM_META = 0x7FFFFFFF
} XrFullBodyJointFB;

XrBodyJointLocationFB
jointLocations[XR_FULL_BODY_JOINT_COUNT_META];
XrBodyJointLocationsFB
locations{XR_TYPE_BODY_JOINT_LOCATIONS_FB};
locations.jointCount = XR_FULL_BODY_JOINT_COUNT_META;
locations.jointLocations = locations;
XrBodyJointsLocateInfoFB
locateInfo{XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB};
locateInfo.baseSpace = GetStageSpace();
locateInfo.time = GetPredictedDisplayTime();
xrLocateBodyJointsFB(bodyTracker, &locateInfo, &locations));

  XrBodyTrackerCreateInfoFB
  createInfo{XR_TYPE_BODY_TRACKER_CREATE_INFO_FB};
  createInfo.bodyJointSet = XR_BODY_JOINT_SET_FULL_BODY_META;
  XrBodyTrackerFB bodyTracker;
  xrCreateBodyTrackerFB(session, &createInfo, &bodyTracker));



  XrBodyTrackingCalibrationInfoMETA calibrationInfo = {XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META};
  calibrationInfo.bodyHeight = 2.5;
  xrSuggestBodyTrackingCalibrationMETA(bodyTracker, &calibrationInfo);

  XrBodyJointLocationFB
  jointLocations[XR_FULL_BODY_JOINT_COUNT_META];
  XrBodyJointLocationsFB
  locations{XR_TYPE_BODY_JOINT_LOCATIONS_FB};
  locations.jointCount = XR_FULL_BODY_JOINT_COUNT_META;
  locations.jointLocations = locations;
  XrBodyTrackingCalibrationStatusMETA calibrationStatus = {XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META};
  Locations.next = &calibrationStatus;
  XrBodyJointsLocateInfoFB
  locateInfo{XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB};
  locateInfo.baseSpace = GetStageSpace();
  locateInfo.time = GetPredictedDisplayTime();
  xrLocateBodyJointsFB(bodyTracker, &locateInfo, &locations));
  if (calibrationStatus.status != XR_BODY_TRACKING_CALIBRATION_STATE_VALID_META) {
      // Don’t use the body tracking result
  }

  typedef enum XrBodyTrackingCalibrationStateMETA {
  XR_BODY_TRACKING_CALIBRATION_STATE_VALID_META = 0;
  XR_BODY_TRACKING_CALIBRATION_STATE_CALIBRATING_META = 1;
  XR_BODY_TRACKING_CALIBRATION_STATE_INVALID_META = 2;
  } XrBodyTrackingCalibrationStateMETA;

• Understand how to set up ISDK and MSDK to be compatible.
• Be able to rig a scene with body tracking using the Movement SDK to allow manipulation of sample virtual objects using the Interaction SDK.

• To enable Capsense with ISDK, set Controller Driven Hand Poses (found on the OVRManager) to Natural.
• In addition, find the OVRHandPrefab objects located in the OVRCameraRig hierarchy, and set the Show State option to Always. This will enable controllers to work with hands.

1. Read the Getting Started with ISDK tutorial or a similar introduction to ISDK. You can add Grab Interactions using building blocks to do a quick set up.
2. On each OVRHand instance, make sure that the “Show State” is set to “Always”.
   
3. Enable the HandGrabVisual and HandGrabGlow components under each HandGrabInteractor.
   

1. Navigate to the “Source Processors” field. Click the “+” symbol.
2. Change the new processor’s “Type” field to “ISDK.”
3. Click on “Setup.” Make sure that the processor finds ISDK’s left and right synthetic hand objects.

In the figure below, the character’s skin influence is currently not shared along limb joints to allow for some joint translation. The picture on the left shows the original character with no mesh weight from the ankle joint, while the version on the right shows the weight influence from the ankle painted to shin.



With the adjusted weighted influence, the fixed ankle can now be translated with deformation affecting the lower shin.



Another example below shows how weight influence can affect the area from the thigh to the knee joint. The left picture shows no weight in that region, while the right counterpart shows some weight influence from the knee painted to the thigh.



The fixed knee can now be translated with deformation result on thigh and knee.



The following gif shows the result in motion. The left side shows the unmodified weight while the right shows the adjusted weight.



In general, we recommend that you extend the impact area of the bones to at least 6 inches above the joint in question so that more mesh vertices are affected during stretching or squishing. The video below shows how to adjust weighting to allow for different heights or body proportions.