• Describe the functionality of Shared Spatial Anchors in a multiplayer environment.
• Explain the steps to configure an app for sharing Spatial Anchors.
• Carry out the steps to share a spatial anchor using the ShareAnchors API.

• Your application must be registered on your developer dashboard, and it must support SSA. See the Shared Spatial Anchor section Set up Project Environment for specifics.
• Set up your chosen network solution in a way that facilitates multiplayer collaboration. More on this in the next section.
• There are also requirements for specific Quest headsets tied to the SDK version used:
  • Meta Quest 3 fully supports Shared Spatial Anchors.
  • Meta Quest Pro supports Shared Spatial Anchors starting in v47.
  • Quest 2 supports Shared Spatial Anchors starting in v49.
  • Quest 1 does not support Shared Spatial Anchors.
• The device setting ‘Enhanced Spatial Services’ must be enabled. It can be found under Settings > Privacy > Device Permissions > Turn on “Enhanced Spatial Services”. More on this below.

• Have a verified Meta developer account. If you haven’t yet, sign-up here.
• Create or join an organization you will develop your app under. For more information, see Manage Your Organization and Users.
• Create an App ID.
• Enable “User ID” and “User Profile” in Data Use Checkup.

1. Obtain admin access to your app if you don’t have it already.
2. Go to the Meta Quest Developer Dashboard.
3. Select your App.
4. In the left-side navigation, click Requirements > Data Use Checkup.
5. Add User ID and User Profile Platform features.
6. Click the Submit recertification button.

1. Generate an array of anchor UUIDs to share.
2. Determine the UUID of the group you wish to share with. This does not have to be a colocation session UUID, it can be any randomly generated ID that all parties have.
3. Use the ShareAnchorsAsync API to generate an AsyncRequest by providing the anchor UUIDs and group UUIDs.
4. A result delegate will fire with success or error codes that determine if the anchors were successfully shared with the specified groups.

Here is a screenshot of what the ShareAnchorsAsync api looks like in blueprint.

Share anchors with Groups C++ example

You are not required to use a lambda as your delegate functor, that is only used to simplify this example.

void ShareAnchors(const TArray<uint64>& Anchors, FOculusXRUUID Group)
{
    OculusXRAnchors::FOculusXRAnchors::ShareAnchorsAsync(
        Anchors,
        {Group},
        FShareAnchorsWithGroups::FCompleteDelegate::CreateLambda([](
            const FShareAnchorsWithGroup::FResultType& Result)
        {
          if (Result.IsSuccess())
          {
            auto value = Result.GetValue();
            // Do something with the value on success
          }
          else
          {
            auto status = Result.GetStatus()
            // Do something with the status code on error
          }
        })
    );
}

1. Save anchors before performing a share request.
2. Generate an array of anchor UUIDs to share.
3. Determine the User IDs of the other players you will share with.
4. Use the ShareAnchors API by providing the anchor UUIDs and User IDs as parameters.
5. Result codes will determine if the anchors were successfully shared with the specified users.

Here is a screenshot of what the ShareAnchors api looks like in blueprint.

Share anchors with User IDs C++ example

You are not required to use a lambda as your delegate functor, that is only used to simplify this example.

EOculusXRAnchorResult::Type ShareAnchors(const TArray<UOculusXRAnchorComponent*>& AnchorComponents, const TArray<FString>& OculusUserIDs)
{
    EOculusXRAnchorResult::Type OutResult; // Detailed immediate (non-async) result code

    OculusXRAnchors::FOculusXRAnchors::ShareAnchors(
        AnchorComponents,
        OculusUserIDs,
        FOculusAnchorShareDelegate::CreateLambda([](
            EOculusResult::Type Result,
            const TArray<UOculusAnchorComponent*>& Anchors,
            const TArray<uint64>& Users)
        {
            // Post-share logic here
        }),
        OutResult
    );

    return OutResult;
}

1. The sharing user needs to notify the other user that an anchor has been shared with them. In Unreal this can be done with an RPC.
2. The receiving user will need to request their shared anchor using the Blueprint or C++ api GetSharedAnchors
3. The result of this function will determine if the anchor is available and has been localized to the receiving user’s device.

Here is a screenshot of what the GetSharedAnchorsAsync API looks like in blueprint.

Get shared anchors from Group C++ example

You are not required to use a lambda as your delegate functor, that is only used to simplify this example.

void GetSharedAnchors(const FOculusXRUUID& GroupUUID)
{
    OculusXRAnchors::FOculusXRAnchors::GetSharedAnchorsAsync(
        GroupUUID,
        FGetAnchorsSharedWithGroup::FCompleteDelegate::CreateLambda([](
            const FGetAnchorsSharedWithGroup::FResultType& Result)
        {
          if (Result.IsSuccess())
          {
            TArray<FOculusXRAnchor> anchors = Result.GetValue();
            for(auto& it : anchors)
            {
              // Do something with the value on success
            }
          }
          else
          {
            auto status = Result.GetStatus()
            // Do something with the status code on error
          }
        })
    );

    return OutResult;
}

Here is a screenshot of what the GetSharedAnchors API looks like in blueprint.

Get shared anchors via User ID Sharing C++ example

You are not required to use a lambda as your delegate functor, that is only used to simplify this example.

EOculusXRAnchorResult::Type GetSharedAnchors(const TArray<FOculusXRUUID*>& AnchorUUIDs)
{
    EOculusXRAnchorResult::Type OutResult; // Detailed immediate (non-async) result code

    OculusXRAnchors::FOculusXRAnchors::GetSharedAnchors(
        AnchorUUIDs,
        FOculusXRGetSharedAnchorsDelegate::CreateLambda([](
            EOculusResult::Type Result,
            const TArray<UOculusXRAnchorsDiscoverResult*> Results)
        {
            // Post-receive logic here
        }),
        OutResult
    );

    return OutResult;
}

• Spatial Anchors
• Samples
• Best Practices
• Troubleshooting
• C++ Reference
• Blueprint Reference

• Unreal-SpatialAnchorsSample
• Unreal-SharedAnchorsSample