718 lines
21 KiB
C++
718 lines
21 KiB
C++
// Copyright® 2015-2023 PICO Technology Co., Ltd. All rights reserved.
|
||
// This plugin incorporates portions of the Unreal® Engine. Unreal® is a trademark or registered trademark of Epic Games, Inc. in the United States of America and elsewhere.
|
||
// Unreal® Engine, Copyright 1998 – 2023, Epic Games, Inc. All rights reserved.
|
||
|
||
#include "PICO_MRAsyncActions.h"
|
||
|
||
#include "PICOOpenXRRuntimeSettings.h"
|
||
#include "PICO_MR.h"
|
||
#include "PICO_SceneCapture.h"
|
||
#include "PICO_SpatialAnchor.h"
|
||
#include "PICO_SpatialMesh.h"
|
||
#include "Async/Async.h"
|
||
#include "Engine/World.h"
|
||
|
||
void URequestSpatialMeshPICO_AsyncAction::Activate()
|
||
{
|
||
EResultPICO Result = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
const bool bStarted = FSpatialMeshExtensionPICO::GetInstance()->RequestSpatialTriangleMesh
|
||
(
|
||
FPICOPollFutureDelegate::CreateUObject(this, &URequestSpatialMeshPICO_AsyncAction::HandleRequestSpatialMeshComplete),Result
|
||
);
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
void URequestSceneCapturesPICO_AsyncAction::Activate()
|
||
{
|
||
EResultPICO OutResult = EResultPICO::XR_Error_RuntimeFailure;
|
||
|
||
const bool bStarted = FSceneCaptureExtensionPICO::GetInstance()->RequestSpatialSceneInfos
|
||
(
|
||
SceneLoadInfo,
|
||
FPICOPollFutureDelegate::CreateUObject(this, &URequestSceneCapturesPICO_AsyncAction::HandleRequestSpatialSceneComplete),
|
||
OutResult
|
||
);
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
}
|
||
URequestSceneCapturesPICO_AsyncAction* URequestSceneCapturesPICO_AsyncAction::RequestSceneCapturesPICO_Async(const FSceneLoadInfoPICO& InSceneLoadInfo)
|
||
{
|
||
URequestSceneCapturesPICO_AsyncAction* Action = NewObject<URequestSceneCapturesPICO_AsyncAction>();
|
||
Action->SceneLoadInfo = InSceneLoadInfo;
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
|
||
return Action;
|
||
}
|
||
|
||
void URequestSceneCapturesPICO_AsyncAction::HandleRequestSpatialSceneComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
TArray<FMRSceneInfoPICO> SceneLoadInfos;
|
||
|
||
if (FSceneCaptureExtensionPICO::GetInstance()->GetSpatialSceneInfos(FutureHandle, SceneLoadInfos, OutResult))
|
||
{
|
||
OnSuccess.Broadcast(OutResult, SceneLoadInfos);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
URequestSpatialMeshPICO_AsyncAction* URequestSpatialMeshPICO_AsyncAction::RequestSpatialMeshInfosPICO_Async()
|
||
{
|
||
URequestSpatialMeshPICO_AsyncAction* Action = NewObject<URequestSpatialMeshPICO_AsyncAction>();
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
|
||
return Action;
|
||
}
|
||
|
||
void URequestSpatialMeshPICO_AsyncAction::HandleRequestSpatialMeshComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [FutureHandle,this]()
|
||
{
|
||
TArray<FSpatialMeshInfoPICO> MeshInfos;
|
||
TSet<FSpatialUUIDPICO> NeedDeleteEntitySet;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
if (FSpatialMeshExtensionPICO::GetInstance()->GetSpatialTriangleMeshInfos(FutureHandle,MeshInfos, OutResult))
|
||
{
|
||
OnSuccess.Broadcast(OutResult, MeshInfos);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
SetReadyToDestroy();
|
||
});
|
||
}
|
||
|
||
void ULaunchSpatialMeshScanningPICO_AsyncAction::Activate()
|
||
{
|
||
if(!FSpatialMeshExtensionPICO::GetInstance()->IsHandleValid())
|
||
{
|
||
const UPICOOpenXRRuntimeSettings* Settings = GetDefault<UPICOOpenXRRuntimeSettings>();
|
||
|
||
if (Settings->bEnableMesh)
|
||
{
|
||
FSenseDataProviderCreateInfoMeshPICO cFPICOSenseDataProviderCreateInfoMesh = {};
|
||
cFPICOSenseDataProviderCreateInfoMesh.Lod = Settings->MeshLod;
|
||
if (Settings->bSemanticsAlignWithTriangle)
|
||
{
|
||
cFPICOSenseDataProviderCreateInfoMesh.ConfigArray.Add(ESpatialMeshConfigPICO::Spatial_Mesh_Config_Semantic);
|
||
}
|
||
else if (Settings->bSemanticsAlignWithVertex)
|
||
{
|
||
cFPICOSenseDataProviderCreateInfoMesh.ConfigArray.Add(ESpatialMeshConfigPICO::Spatial_Mesh_Config_Semantic);
|
||
cFPICOSenseDataProviderCreateInfoMesh.ConfigArray.Add(ESpatialMeshConfigPICO::Spatial_Mesh_Config_Semantic_Align_With_Vertex);
|
||
}
|
||
EResultPICO OutResult=EResultPICO::XR_Error_Unknown_PICO;
|
||
FSpatialMeshExtensionPICO::GetInstance()->CreateProvider(cFPICOSenseDataProviderCreateInfoMesh,OutResult);
|
||
}
|
||
}
|
||
|
||
EResultPICO Result=EResultPICO::XR_Error_Unknown_PICO;
|
||
const bool bStarted = FSpatialMeshExtensionPICO::GetInstance()->StartProvider
|
||
(
|
||
FPICOPollFutureDelegate::CreateUObject(this,
|
||
&ULaunchSpatialMeshScanningPICO_AsyncAction::HandleLaunchMeshScanningComplete)
|
||
,Result
|
||
);
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
ULaunchSpatialMeshScanningPICO_AsyncAction* ULaunchSpatialMeshScanningPICO_AsyncAction::LaunchSpatialMeshScanningPICO_Async()
|
||
{
|
||
ULaunchSpatialMeshScanningPICO_AsyncAction* Action = NewObject<ULaunchSpatialMeshScanningPICO_AsyncAction>();
|
||
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
|
||
return Action;
|
||
}
|
||
|
||
void ULaunchSpatialMeshScanningPICO_AsyncAction::HandleLaunchMeshScanningComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSenseDataProviderStartCompletionPICO SenseDataProviderStartCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if (FSpatialSensingExtensionPICO::GetInstance()->StartSenseDataProviderComplete(FutureHandle, SenseDataProviderStartCompletion,OutResult))
|
||
{
|
||
if (PXR_SUCCESS(SenseDataProviderStartCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(SenseDataProviderStartCompletion.FutureResult);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SenseDataProviderStartCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
void ULaunchSpatialAnchorServicePICO_AsyncAction::Activate()
|
||
{
|
||
if(!FSpatialAnchorExtensionPICO::GetInstance()->IsHandleValid())
|
||
{
|
||
const UPICOOpenXRRuntimeSettings* Settings = GetDefault<UPICOOpenXRRuntimeSettings>();
|
||
if (Settings->bEnableAnchor)
|
||
{
|
||
FSenseDataProviderCreateInfoAnchorPICO cFPICOSenseDataProviderCreateInfoAnchor = {};
|
||
EResultPICO OutResult=EResultPICO::XR_Error_Unknown_PICO;
|
||
FSpatialAnchorExtensionPICO::GetInstance()->CreateProvider(cFPICOSenseDataProviderCreateInfoAnchor,OutResult);
|
||
}
|
||
}
|
||
EResultPICO Result=EResultPICO::XR_Error_Unknown_PICO;
|
||
const bool bStarted = FSpatialAnchorExtensionPICO::GetInstance()->StartProvider(
|
||
FPICOPollFutureDelegate::CreateUObject(
|
||
this,
|
||
&ULaunchSpatialAnchorServicePICO_AsyncAction::HandleLaunchSpatialAnchorServiceComplete),
|
||
Result
|
||
);
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
ULaunchSpatialAnchorServicePICO_AsyncAction* ULaunchSpatialAnchorServicePICO_AsyncAction::LaunchSpatialAnchorServicePICO_Async()
|
||
{
|
||
ULaunchSpatialAnchorServicePICO_AsyncAction* Action = NewObject<ULaunchSpatialAnchorServicePICO_AsyncAction>();
|
||
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
|
||
return Action;
|
||
}
|
||
|
||
void ULaunchSpatialAnchorServicePICO_AsyncAction::HandleLaunchSpatialAnchorServiceComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSenseDataProviderStartCompletionPICO SenseDataProviderStartCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if (FSpatialSensingExtensionPICO::GetInstance()->StartSenseDataProviderComplete(FutureHandle, SenseDataProviderStartCompletion,OutResult))
|
||
{
|
||
if (PXR_SUCCESS(SenseDataProviderStartCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(SenseDataProviderStartCompletion.FutureResult);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SenseDataProviderStartCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
void ULaunchSceneCaptureServicePICO_AsyncAction::Activate()
|
||
{
|
||
if(!FSceneCaptureExtensionPICO::GetInstance()->IsHandleValid())
|
||
{
|
||
const UPICOOpenXRRuntimeSettings* Settings = GetDefault<UPICOOpenXRRuntimeSettings>();
|
||
if (Settings->bEnableSceneCapture)
|
||
{
|
||
FSenseDataProviderCreateInfoSceneCapturePICO cSenseDataProviderCreateInfoSceneCapture = {};
|
||
EResultPICO OutResult=EResultPICO::XR_Error_Unknown_PICO;
|
||
FSceneCaptureExtensionPICO::GetInstance()->CreateProvider(cSenseDataProviderCreateInfoSceneCapture,OutResult);
|
||
}
|
||
}
|
||
|
||
EResultPICO Result=EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
const bool bStarted = FSceneCaptureExtensionPICO::GetInstance()->StartProvider(
|
||
FPICOPollFutureDelegate::CreateUObject(this,
|
||
&ULaunchSceneCaptureServicePICO_AsyncAction::HandleLaunchSceneCaptureServiceComplete)
|
||
, Result);
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
ULaunchSceneCaptureServicePICO_AsyncAction* ULaunchSceneCaptureServicePICO_AsyncAction::LaunchSceneCaptureServicePICO_Async()
|
||
{
|
||
ULaunchSceneCaptureServicePICO_AsyncAction* Action = NewObject<ULaunchSceneCaptureServicePICO_AsyncAction>();
|
||
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
|
||
return Action;
|
||
}
|
||
|
||
void ULaunchSceneCaptureServicePICO_AsyncAction::HandleLaunchSceneCaptureServiceComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSenseDataProviderStartCompletionPICO SenseDataProviderStartCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if (FSpatialSensingExtensionPICO::GetInstance()->StartSenseDataProviderComplete(FutureHandle, SenseDataProviderStartCompletion,OutResult))
|
||
{
|
||
if (PXR_SUCCESS(SenseDataProviderStartCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(SenseDataProviderStartCompletion.FutureResult);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SenseDataProviderStartCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
void ULaunchSceneCaptureAppPICO_AsyncAction::HandleLaunchSceneCaptureAppComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSceneCaptureStartCompletionPICO cPICOSceneCaptureStartCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if (FSceneCaptureExtensionPICO::GetInstance()->StartSceneCaptureComplete(FutureHandle, cPICOSceneCaptureStartCompletion,OutResult))
|
||
{
|
||
if (PXR_SUCCESS(cPICOSceneCaptureStartCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(cPICOSceneCaptureStartCompletion.FutureResult);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(cPICOSceneCaptureStartCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
ULaunchSceneCaptureAppPICO_AsyncAction* ULaunchSceneCaptureAppPICO_AsyncAction::LaunchSceneCaptureAppPICO_Async()
|
||
{
|
||
ULaunchSceneCaptureAppPICO_AsyncAction* Action = NewObject<ULaunchSceneCaptureAppPICO_AsyncAction>();
|
||
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
|
||
return Action;
|
||
}
|
||
|
||
void ULaunchSceneCaptureAppPICO_AsyncAction::Activate()
|
||
{
|
||
EResultPICO Result = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
bool bStarted = FSceneCaptureExtensionPICO::GetInstance()->StartSceneCaptureAsync
|
||
(
|
||
FPICOPollFutureDelegate::CreateUObject(this, &ULaunchSceneCaptureAppPICO_AsyncAction::HandleLaunchSceneCaptureAppComplete),
|
||
Result
|
||
);
|
||
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
/// Create Anchor Entity
|
||
//////////////////////////////////////////////////////////////////////////
|
||
void UCreateSpatialAnchorPICO_AsyncAction::Activate()
|
||
{
|
||
if (!IsValid(BoundActor) || !IsValid(BoundActor->GetWorld()))
|
||
{
|
||
OnFailure.Broadcast(EResultPICO::XR_Error_ValidationFailure);
|
||
return;
|
||
}
|
||
|
||
EResultPICO Result = EResultPICO::XR_Error_Unknown_PICO;
|
||
bool bStarted = FSpatialAnchorExtensionPICO::GetInstance()->CreateSpatialAnchorAsync
|
||
(
|
||
FPICOPollFutureDelegate::CreateUObject(this, &UCreateSpatialAnchorPICO_AsyncAction::HandleCreateSpatialAnchorComplete)
|
||
, SpatialAnchorTransform
|
||
,Result
|
||
);
|
||
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
UCreateSpatialAnchorPICO_AsyncAction* UCreateSpatialAnchorPICO_AsyncAction::CreateSpatialAnchorPICO_Async(AActor* BoundActor, const FTransform& InSpatialAnchorTransform)
|
||
{
|
||
UCreateSpatialAnchorPICO_AsyncAction* Action = NewObject<UCreateSpatialAnchorPICO_AsyncAction>();
|
||
Action->BoundActor = BoundActor;
|
||
Action->SpatialAnchorTransform = InSpatialAnchorTransform;
|
||
|
||
if (IsValid(BoundActor))
|
||
{
|
||
Action->RegisterWithGameInstance(BoundActor->GetWorld());
|
||
}
|
||
else
|
||
{
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
}
|
||
|
||
return Action;
|
||
}
|
||
|
||
void UCreateSpatialAnchorPICO_AsyncAction::HandleCreateSpatialAnchorComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSpatialAnchorCreateCompletionPICO SpatialAnchorCreateCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if(FSpatialAnchorExtensionPICO::GetInstance()->CreateSpatialAnchorComplete(FutureHandle, SpatialAnchorCreateCompletion,OutResult))
|
||
{
|
||
UAnchorComponentPICO* AnchorComponent = Cast<UAnchorComponentPICO>(BoundActor->GetComponentByClass(UAnchorComponentPICO::StaticClass()));
|
||
if (!AnchorComponent)
|
||
{
|
||
AnchorComponent = Cast<UAnchorComponentPICO>(BoundActor->AddComponentByClass(UAnchorComponentPICO::StaticClass(), false, FTransform::Identity, false));
|
||
}
|
||
AnchorComponent->SetAnchorHandle(SpatialAnchorCreateCompletion.AnchorHandle);
|
||
|
||
if(PXR_SUCCESS(SpatialAnchorCreateCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(SpatialAnchorCreateCompletion.FutureResult,AnchorComponent);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SpatialAnchorCreateCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
/// Persist Anchor Entity
|
||
//////////////////////////////////////////////////////////////////////////
|
||
void UPersistSpatialAnchorPICO_AsyncAction::Activate()
|
||
{
|
||
if (!IsValid(BoundActor))
|
||
{
|
||
OnFailure.Broadcast(EResultPICO::XR_Error_ValidationFailure);
|
||
return;
|
||
}
|
||
EResultPICO Result = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
bool bStarted = false;
|
||
|
||
switch (PersistLocation)
|
||
{
|
||
case EPersistLocationPICO::PersistLocation_Local:
|
||
{
|
||
bStarted = FSpatialAnchorExtensionPICO::GetInstance()->PersistSpatialAnchorAsync
|
||
(
|
||
BoundActor,
|
||
PersistLocation,
|
||
FPICOPollFutureDelegate::CreateUObject(this, &UPersistSpatialAnchorPICO_AsyncAction::HandlePersistSpatialAnchorComplete),
|
||
Result
|
||
);
|
||
}
|
||
break;
|
||
case EPersistLocationPICO::PersistLocation_Shared:
|
||
{
|
||
bStarted = FSpatialAnchorExtensionPICO::GetInstance()->ShareSpatialAnchorAsync
|
||
(
|
||
BoundActor,
|
||
FPICOPollFutureDelegate::CreateUObject(this, &UPersistSpatialAnchorPICO_AsyncAction::HandleShareSpatialAnchorComplete),
|
||
Result
|
||
);
|
||
}
|
||
break;
|
||
default: ;
|
||
}
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
UPersistSpatialAnchorPICO_AsyncAction* UPersistSpatialAnchorPICO_AsyncAction::PersistSpatialAnchorPICO_Async(AActor* InBoundActor, EPersistLocationPICO InPersistLocation)
|
||
{
|
||
UPersistSpatialAnchorPICO_AsyncAction* Action = NewObject<UPersistSpatialAnchorPICO_AsyncAction>();
|
||
Action->BoundActor = InBoundActor;
|
||
Action->PersistLocation = InPersistLocation;
|
||
|
||
if (IsValid(InBoundActor))
|
||
{
|
||
Action->RegisterWithGameInstance(InBoundActor->GetWorld());
|
||
}
|
||
else
|
||
{
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
}
|
||
|
||
return Action;
|
||
}
|
||
|
||
void UPersistSpatialAnchorPICO_AsyncAction::HandlePersistSpatialAnchorComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSpatialAnchorPersistCompletionPICO SpatialAnchorPersistCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if (FSpatialAnchorExtensionPICO::GetInstance()->PersistSpatialAnchorComplete(FutureHandle, SpatialAnchorPersistCompletion,OutResult))
|
||
{
|
||
UAnchorComponentPICO* AnchorComponent = Cast<UAnchorComponentPICO>(BoundActor->GetComponentByClass(UAnchorComponentPICO::StaticClass()));
|
||
if (IsValid(AnchorComponent) && AnchorComponent->IsAnchorValid())
|
||
{
|
||
if(PXR_SUCCESS(SpatialAnchorPersistCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(SpatialAnchorPersistCompletion.FutureResult,AnchorComponent);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SpatialAnchorPersistCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(EResultPICO::XR_Error_ValidationFailure);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
void UPersistSpatialAnchorPICO_AsyncAction::HandleShareSpatialAnchorComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSpatialAnchorShareCompletionPICO SpatialAnchorShareCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if (FSpatialAnchorExtensionPICO::GetInstance()->ShareSpatialAnchorComplete(FutureHandle, SpatialAnchorShareCompletion,OutResult))
|
||
{
|
||
UAnchorComponentPICO* AnchorComponent = Cast<UAnchorComponentPICO>(BoundActor->GetComponentByClass(UAnchorComponentPICO::StaticClass()));
|
||
if (IsValid(AnchorComponent) && AnchorComponent->IsAnchorValid())
|
||
{
|
||
if(PXR_SUCCESS(SpatialAnchorShareCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(SpatialAnchorShareCompletion.FutureResult,AnchorComponent);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SpatialAnchorShareCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(EResultPICO::XR_Error_ValidationFailure);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
/// Unpersist Anchor Entity
|
||
//////////////////////////////////////////////////////////////////////////
|
||
void UUnpersistSpatialAnchorPICO_AsyncAction::Activate()
|
||
{
|
||
if (!IsValid(BoundActor))
|
||
{
|
||
OnFailure.Broadcast(EResultPICO::XR_Error_ValidationFailure);
|
||
return;
|
||
}
|
||
bool bStarted=false;
|
||
EResultPICO Result = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
bStarted = FSpatialAnchorExtensionPICO::GetInstance()->UnpersistSpatialAnchorAsync(
|
||
BoundActor,
|
||
FPICOPollFutureDelegate::CreateUObject(this, &UUnpersistSpatialAnchorPICO_AsyncAction::HandleUnpersistSpatialAnchorComplete),
|
||
Result
|
||
);
|
||
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
UUnpersistSpatialAnchorPICO_AsyncAction* UUnpersistSpatialAnchorPICO_AsyncAction::UnpersistSpatialAnchorPICO_Async(AActor* BoundActor, EPersistLocationPICO InPersistLocation)
|
||
{
|
||
UUnpersistSpatialAnchorPICO_AsyncAction* Action = NewObject<UUnpersistSpatialAnchorPICO_AsyncAction>();
|
||
Action->BoundActor = BoundActor;
|
||
Action->PersistLocation = InPersistLocation;
|
||
|
||
if (IsValid(BoundActor))
|
||
{
|
||
Action->RegisterWithGameInstance(BoundActor->GetWorld());
|
||
}
|
||
else
|
||
{
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
}
|
||
|
||
return Action;
|
||
}
|
||
|
||
void UUnpersistSpatialAnchorPICO_AsyncAction::HandleUnpersistSpatialAnchorComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
FSpatialAnchorUnpersistCompletionPICO SpatialAnchorUnpersistCompletion;
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
if(FSpatialAnchorExtensionPICO::GetInstance()->UnpersistSpatialAnchorComplete(FutureHandle, SpatialAnchorUnpersistCompletion,OutResult))
|
||
{
|
||
UAnchorComponentPICO* AnchorComponent = Cast<UAnchorComponentPICO>(BoundActor->GetComponentByClass(UAnchorComponentPICO::StaticClass()));
|
||
if (IsValid(AnchorComponent) && AnchorComponent->IsAnchorValid())
|
||
{
|
||
if(PXR_SUCCESS(SpatialAnchorUnpersistCompletion.FutureResult))
|
||
{
|
||
OnSuccess.Broadcast(SpatialAnchorUnpersistCompletion.FutureResult,AnchorComponent);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SpatialAnchorUnpersistCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(EResultPICO::XR_Error_ValidationFailure);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
/// Load Anchor Entity
|
||
//////////////////////////////////////////////////////////////////////////
|
||
void URequestSpatialAnchorsPICO_AsyncAction::Activate()
|
||
{
|
||
bool bStarted = false;
|
||
EResultPICO Result = EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
FutureHandleSet.Empty();
|
||
switch (LoadInfo.PersistLocation)
|
||
{
|
||
case EPersistLocationPICO::PersistLocation_Local:
|
||
{
|
||
bStarted = FSpatialAnchorExtensionPICO::GetInstance()->LoadAnchorEntityAsync
|
||
(
|
||
LoadInfo,
|
||
FPICOPollFutureDelegate::CreateUObject(this, &URequestSpatialAnchorsPICO_AsyncAction::HandleLoadSpatialAnchorsComplete),
|
||
Result
|
||
);
|
||
}
|
||
break;
|
||
case EPersistLocationPICO::PersistLocation_Shared:
|
||
{
|
||
bStarted = FSpatialAnchorExtensionPICO::GetInstance()->DownloadSharedSpatialAnchorsAsync
|
||
(
|
||
LoadInfo,
|
||
FPICOPollFutureDelegate::CreateUObject(this,&URequestSpatialAnchorsPICO_AsyncAction::HandleDownloadSharedAnchorsComplete),
|
||
FutureHandleSet,
|
||
Result
|
||
);
|
||
}
|
||
break;
|
||
default: ;
|
||
}
|
||
|
||
if (!bStarted)
|
||
{
|
||
OnFailure.Broadcast(Result);
|
||
}
|
||
}
|
||
|
||
URequestSpatialAnchorsPICO_AsyncAction* URequestSpatialAnchorsPICO_AsyncAction::LoadSpatialAnchorPICO_Async(const FAnchorLoadInfoPICO& InLoadInfo)
|
||
{
|
||
URequestSpatialAnchorsPICO_AsyncAction* Action = NewObject<URequestSpatialAnchorsPICO_AsyncAction>();
|
||
Action->LoadInfo = InLoadInfo;
|
||
Action->RegisterWithGameInstance(GWorld);
|
||
return Action;
|
||
}
|
||
|
||
void URequestSpatialAnchorsPICO_AsyncAction::HandleLoadSpatialAnchorsComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
EResultPICO LoadResult=EResultPICO::XR_Error_Unknown_PICO;
|
||
|
||
TArray<FAnchorLoadResultPICO> AnchorLoadResults;
|
||
|
||
if (FSpatialAnchorExtensionPICO::GetInstance()->GetAnchorLoadResults(FutureHandle,AnchorLoadResults,LoadResult))
|
||
{
|
||
OnSuccess.Broadcast(LoadResult,AnchorLoadResults);
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(LoadResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
}
|
||
|
||
void URequestSpatialAnchorsPICO_AsyncAction::HandleDownloadSharedAnchorsComplete(const XrFutureEXT& FutureHandle)
|
||
{
|
||
EResultPICO OutResult = EResultPICO::XR_Error_Unknown_PICO;
|
||
FSharedSpatialAnchorDownloadCompletionPICO SharedSpatialAnchorDownloadCompletion;
|
||
FutureHandleSet.Remove(FutureHandle);
|
||
if(FSpatialAnchorExtensionPICO::GetInstance()->DownloadSharedSpatialAnchorsComplete(FutureHandle, SharedSpatialAnchorDownloadCompletion,OutResult))
|
||
{
|
||
if(PXR_SUCCESS(SharedSpatialAnchorDownloadCompletion.FutureResult))
|
||
{
|
||
if (!FutureHandleSet.Num())
|
||
{
|
||
if(!FSpatialAnchorExtensionPICO::GetInstance()->LoadAnchorEntityAsync(
|
||
LoadInfo,
|
||
FPICOPollFutureDelegate::CreateUObject(this, &URequestSpatialAnchorsPICO_AsyncAction::HandleLoadSpatialAnchorsComplete),
|
||
OutResult
|
||
))
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(SharedSpatialAnchorDownloadCompletion.FutureResult);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
OnFailure.Broadcast(OutResult);
|
||
}
|
||
|
||
SetReadyToDestroy();
|
||
} |