Use Spatial Anchors

1. In Edit > Project Settings > OculusVR:
   1. In the General section, go to the XR API list, and then select OVRPlugin OpenXR.
   2. 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(bool Success, UOculusAnchorComponent* Anchor)
{
    UE_LOG(LogTemp, Log, TEXT(“Success: %d”), Success);
}

// Somewhere else in the code
OculusAnchors::CreateSpatialAnchor(
    TargetActor->GetActorTransform(),
    TargetActor,
    FOculusSpatialAnchorCreateDelegate::CreateRaw(SomePointer, &SomeClass::CreateAnchorCallback);

1. Spawn an actor.
   • This actor does not have to have a spatial anchor component attached.
2. Call the Blueprint method Oculus 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 Oculus 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 Oculus 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 Oculus 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 Oculus Async Query Anchors.
   • Specify the location to save to, this can be local or cloud.
3. If successful, iterate the query results and then construct new actors using the Spawn Oculus Anchor Actor function.

1. Spawn an actor.
   • This actor does not have to have a spatial anchor component attached.
2. Call the method OculusAnchors::CreateSpatialAnchor and pass the anchor transform, actor, and result delegate 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>();

OculusAnchors::FOculusAnchors::CreateSpatialAnchor(NewActor->GetActorTransform(),
NewActor, FOculusSpatialAnchorCreateDelegate::CreateLambda([](bool Success,
UOculusAnchorComponent* AnchorComponent)
    {
        // Post-create logic in here
    })
);

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

UOculusAnchorComponent* AnchorComponent = … // Retrieve anchor

OculusAnchors::FOculusAnchors::EraseAnchor(AnchorComponent,
    FOculusAnchorEraseDelegate::CreateLambda([](bool Success, FUUID UUID)
    {
        // Post-erase logic here
    })
);

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

UOculusAnchorComponent* AnchorComponent = … // Retrieve anchor

OculusAnchors::FOculusAnchors::SaveAnchor(AnchorComponent,
EOculusSpaceStorageLocation::Local, FOculusAnchorSaveDelegate::CreateLambda([](bool
Success, UOculusAnchorComponent* AnchorComponent)
    {
        // Post-save logic here
    })
);

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

UOculusAnchorComponent* AnchorComponent = … // Retrieve anchor

OculusAnchors::FOculusAnchors::SaveAnchor(AnchorComponent,
EOculusSpaceStorageLocation::Local, FOculusAnchorSaveDelegate::CreateLambda([](bool
Success, UOculusAnchorComponent* AnchorComponent)
    {
        // Post-save logic here
    })
);

1. Generate a list of UUIDs,
2. Call the method OculusAnchors::QueryAnchors and pass the list of UUIDs, the query location, the maximum number of anchors to load, and the result delegate 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 SpawnActorWithAnchorQueryResults.

uint32 MaxAnchorsToLoad = 16;
EOculusSpaceStorageLocation QueryLocation = EOculusSpaceStorageLocation::Local;
TArray<FUUID> AnchorUUIDs = ...;

OculusAnchors::FOculusAnchors::QueryAnchors(AnchorUUIDs, QueryLocation, MaxAnchorsToLoad,
    FOculusAnchorQueryDelegate::CreateLambda([](bool Success, const
TArray<FOculusSpaceQueryResult>& Results)
    {
        if(Success)
        {
            for(auto& it : Results)
            {
                UOculusAnchorBPFuctionLibrary::SpawnActorWithAnchorQueryResults(
                    GetWorld(),
                    it,
                    AActor::StaticClass(), // Your class here
                    Owner,
                    Instigator,
                    CollisionHandlingMethod
                );
            }
        }
    })
);

UENUM(BlueprintType)
namespace EOculusResult
{
	enum Type
	{
		Success = 0,
		Success_EventUnavailable = 1,
		Success_Pending = 2,

		/// Failure
		Failure = -1000,
		Failure_InvalidParameter = -1001,
		Failure_NotInitialized = -1002,
		Failure_InvalidOperation = -1003,
		Failure_Unsupported = -1004,
		Failure_NotYetImplemented = -1005,
		Failure_OperationFailed = -1006,
		Failure_InsufficientSize = -1007,
		Failure_DataIsInvalid = -1008,
		Failure_DeprecatedOperation = -1009,
		Failure_ErrorLimitReached = -1010,
		Failure_ErrorInitializationFailed = -1011,

		/// Space error cases
		Failure_SpaceCloudStorageDisabled = -2000,
		Failure_SpaceMappingInsufficient = -2001,
		Failure_SpaceLocalizationFailed = -2002,
		Failure_SpaceNetworkTimeout = -2003,
		Failure_SpaceNetworkRequestFailed = -2004
	};
}

• 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.

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 nodes.
2. Execute Success of Failure pins based on results.