Use Spatial Anchors

1. In Edit > Project Settings > Plugins > Meta XR, in the Mobile section, select Passthrough Enabled and Anchor Support.
2. Follow the typical steps for adding a Passthrough layer to an Unreal project.

void CreateAnchorCallback(EOculusXRAnchorResult::Type Result, UOculusXRAnchorComponent* Anchor)
{
    UE_LOG(LogTemp, Log, TEXT("Result: %s"), *UEnum::GetValueAsString(Result));
}

// Somewhere else in the code
EOculusXRAnchorResult::Type OutResult;
OculusXRAnchors::FOculusXRAnchors::CreateSpatialAnchor(
    TargetActor->GetActorTransform(),
    TargetActor,
    FOculusXRSpatialAnchorCreateDelegate::CreateRaw(SomePointer, &SomeClass::CreateAnchorCallback),
    OutResult);

1. Spawn an actor.
   • This actor does not have to have a spatial anchor component attached.
2. Call the Blueprint method OculusXR Async Create Spatial Anchor and pass in the anchor transform and actor as parameters.
   • If the specified actor does not have a spatial anchor component attached, a new component is constructed for you.
3. Execute logic using the Success and Failure pins.
   • The resulting Anchor component output is only valid in the case of success.

1. Call the Blueprint method OculusXR Async Erase Anchor.
2. Pass in an actor that has a spatial anchor attached.
3. Execute logic using the Success or Failure pins.
   • The resulting Actor and UUID output is only valid in the case of success.
   • The UUID of the destroyed anchor is returned for your bookkeeping.

1. Call the Blueprint method OculusXR Async Save Anchor.
   • Specify the target actor that has a spatial anchor attached.
   • Specify the storage location. This is either Local or Cloud.
2. Execute logic using the Success or Failure pins.
   • The output Anchor Component is only valid if success is executed.

1. Call the Blueprint method OculusXR Async Save Anchors.
   • Specify the target actors that have spatial anchors attached.
   • Specify the storage location. This is either Local or Cloud.
2. Execute logic using the Success or Failure pins.
   • The output Anchor Components array is only valid if success is executed.

1. Get a list of Anchor UUIDs to request loading.
   • This can be from a save game or anywhere else you are storing UUIDs.
2. Call the Blueprint method OculusXR Async Query Anchors.
   • Specify the storage location to query from. This can be Local or Cloud.
3. If successful, iterate the query results and then construct new actors using the Spawn Oculus Anchor Actor From Query function.

1. Spawn an actor.
   • This actor does not have to have a spatial anchor component attached.
2. Call the method OculusXRAnchors::FOculusXRAnchors::CreateSpatialAnchor and pass the anchor transform, actor, result delegate, and output result in as parameters.
   • If the specified actor does not have a spatial anchor component attached, a new component is constructed for you.
3. Execute logic in the results delegate.
   • The resulting spatial anchor component is only valid in the case of success.

AActor* NewActor = GetWorld()->SpawnActor<AActor>();

EOculusXRAnchorResult::Type OutResult;
OculusXRAnchors::FOculusXRAnchors::CreateSpatialAnchor(NewActor->GetActorTransform(),
    NewActor,
    FOculusXRSpatialAnchorCreateDelegate::CreateLambda([](EOculusXRAnchorResult::Type Result,
    UOculusXRAnchorComponent* AnchorComponent)
    {
        // Post-create logic in here
    }),
    OutResult
);

1. Retrieve an anchor from an actor.
2. Call the method OculusXRAnchors::FOculusXRAnchors::EraseAnchor and pass the anchor component, result delegate, and output result in as parameters.
3. Execute logic in the results delegate.
   • The resulting UUID is only valid in the case of success.

UOculusXRAnchorComponent* AnchorComponent = ...; // Retrieve anchor

EOculusXRAnchorResult::Type OutResult;
OculusXRAnchors::FOculusXRAnchors::EraseAnchor(AnchorComponent,
    FOculusXRAnchorEraseDelegate::CreateLambda([](EOculusXRAnchorResult::Type Result,
    FOculusXRUUID UUID)
    {
        // Post-erase logic here
    }),
    OutResult
);

1. Retrieve an anchor from an actor.
2. Call the method OculusXRAnchors::FOculusXRAnchors::SaveAnchor and pass the anchor component, storage location, result delegate, and output result in as parameters.
3. Execute logic in the results delegate.
   • The resulting AnchorComponent is only valid in the case of success.

UOculusXRAnchorComponent* AnchorComponent = ...; // Retrieve anchor

EOculusXRAnchorResult::Type OutResult;
OculusXRAnchors::FOculusXRAnchors::SaveAnchor(AnchorComponent,
    EOculusXRSpaceStorageLocation::Local,
    FOculusXRAnchorSaveDelegate::CreateLambda([](EOculusXRAnchorResult::Type Result,
    UOculusXRAnchorComponent* AnchorComponent)
    {
        // Post-save logic here
    }),
    OutResult
);

1. Retrieve a list of anchors from actors.
2. Call the method OculusXRAnchors::FOculusXRAnchors::SaveAnchorList and pass the array of anchor components, storage location, result delegate, and output result in as parameters.
3. Execute logic in the results delegate.
   • The resulting SavedAnchors array is only valid in the case of success.

TArray<UOculusXRAnchorComponent*> AnchorComponents = ...; // Retrieve anchors

EOculusXRAnchorResult::Type OutResult;
OculusXRAnchors::FOculusXRAnchors::SaveAnchorList(AnchorComponents,
    EOculusXRSpaceStorageLocation::Local,
    FOculusXRAnchorSaveListDelegate::CreateLambda([](EOculusXRAnchorResult::Type Result,
    const TArray<UOculusXRAnchorComponent*>& SavedAnchors)
    {
        // Post-save logic here
    }),
    OutResult
);

1. Generate a list of UUIDs.
2. Call the method OculusXRAnchors::FOculusXRAnchors::QueryAnchors and pass the list of UUIDs, the query location, the result delegate, and the output result in as parameters.
3. Execute logic in the results delegate.
   • Spawn an actor of your choice. There is a helper method you can use called UOculusXRAnchorBPFunctionLibrary::SpawnActorWithAnchorQueryResults.

EOculusXRSpaceStorageLocation QueryLocation = EOculusXRSpaceStorageLocation::Local;
TArray<FOculusXRUUID> AnchorUUIDs = ...;

EOculusXRAnchorResult::Type OutResult;
OculusXRAnchors::FOculusXRAnchors::QueryAnchors(AnchorUUIDs, QueryLocation,
    FOculusXRAnchorQueryDelegate::CreateLambda([this](EOculusXRAnchorResult::Type Result,
    const TArray<FOculusXRSpaceQueryResult>& Results)
    {
        if (Result == EOculusXRAnchorResult::Success)
        {
            for (auto& it : Results)
            {
                UOculusXRAnchorBPFunctionLibrary::SpawnActorWithAnchorQueryResults(
                    GetWorld(),
                    it,
                    AActor::StaticClass(), // Your class here
                    Owner,
                    Instigator,
                    CollisionHandlingMethod
                );
            }
        }
    }),
    OutResult
);

UENUM(BlueprintType)
namespace EOculusXRAnchorResult
{
	enum Type
	{
		Success,

		/// Failure
		Failure,
		Failure_InvalidParameter,
		Failure_NotInitialized,
		Failure_InvalidOperation,
		Failure_Unsupported,
		Failure_NotYetImplemented,
		Failure_OperationFailed,
		Failure_InsufficientSize,
		Failure_DataIsInvalid,
		Failure_DeprecatedOperation,
		Failure_ErrorLimitReached,
		Failure_ErrorInitializationFailed,

		/// Space error cases
		Failure_SpaceCloudStorageDisabled,
		Failure_SpaceMappingInsufficient,
		Failure_SpaceLocalizationFailed,
		Failure_SpaceNetworkTimeout,
		Failure_SpaceNetworkRequestFailed,
		Failure_SpaceInsufficientResources,
		Failure_SpaceStorageAtCapacity,
		Failure_SpaceInsufficientView,
		Failure_SpacePermissionInsufficient,
		Failure_SpaceRateLimited,
		Failure_SpaceTooDark,
		Failure_SpaceTooBright,

		/// Warning
		Warning_BoundaryVisibilitySuppressionNotAllowed,
	};
}

• Failure_SpaceCloudStorageDisabled: Saving anchors to cloud storage is not permitted by the user.
• Failure_SpaceMappingInsufficient: The user did not move around enough for a reliable localization. The user should walk and look around their space before calling save again. For example, the user could walk in a large circle around the center of their playspace.
• Failure_SpaceLocalizationFailed: The system failed to localize the shared anchor. This could be because the shared anchor is not near the user when calling Query.
• Failure_SpaceNetworkTimeout: Network operation timed out.
• Failure_SpaceNetworkRequestFailed: Network operation failed.
• Failure_SpaceInsufficientResources: System ran out of resources for spatial anchors.
• Failure_SpaceStorageAtCapacity: Anchor storage has reached its capacity.
• Failure_SpaceInsufficientView: The system does not have a sufficient view of the environment.
• Failure_SpacePermissionInsufficient: The app does not have sufficient permissions.
• Failure_SpaceRateLimited: The spatial anchor request was rate limited.
• Failure_SpaceTooDark: The environment is too dark for spatial anchors.
• Failure_SpaceTooBright: The environment is too bright for spatial anchors.
• Warning_BoundaryVisibilitySuppressionNotAllowed: Boundary visibility suppression is not allowed.

1. Bind a callback, usually in begin play, to the Spatial Anchors event you are listening for.
2. Execute a Spatial Anchors method, in this case “Create Spatial Anchor”.
3. Wait for the bound callback to execute.
4. Complete any work necessary in the callback.

1. Execute a latent action Blueprint node.
2. Execute Success or Failure pins based on results.