1038 lines
30 KiB
C++
1038 lines
30 KiB
C++
// Copyright 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.
|
|
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "PXR_MRAsyncActions.h"
|
|
#include "PXR_ProviderManager.h"
|
|
#include "PXR_Log.h"
|
|
#include "Async/Async.h"
|
|
|
|
void UPICORequestSpatialMesh_AsyncAction::Activate()
|
|
{
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
|
|
const bool bStarted = PXR_MeshProvider::GetInstance()->RequestSpatialTriangleMesh
|
|
(
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICORequestSpatialMesh_AsyncAction::HandleRequestSpatialMeshComplete),Result
|
|
);
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
void UPICORequestSceneCaptures_AsyncAction::Activate()
|
|
{
|
|
bool bStarted;
|
|
EPICOResult Result = EPICOResult::PXR_Error_RuntimeFailure;
|
|
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->LoadAnchorEntityLegacy
|
|
(
|
|
EPICOLoadFilterType::LoadFilterType_SpatialSceneData,
|
|
FPICOAnchorLoadInfo(),
|
|
SceneLoadInfo,
|
|
FPICOLoadAnchorEntityDelegate::CreateUObject(this, &UPICORequestSceneCaptures_AsyncAction::HandleLoadSceneAnchorEntityComplete),
|
|
Result
|
|
);
|
|
}
|
|
else
|
|
{
|
|
bStarted = PXR_SceneProvider::GetInstance()->RequestSpatialSceneInfos
|
|
(
|
|
SceneLoadInfo,
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICORequestSceneCaptures_AsyncAction::HandleRequestSpatialSceneComplete),
|
|
Result
|
|
);
|
|
}
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
UPICORequestSceneCaptures_AsyncAction* UPICORequestSceneCaptures_AsyncAction::PXR_RequestSceneCaptures_Async(const FPICOSceneLoadInfo& InSceneLoadInfo)
|
|
{
|
|
UPICORequestSceneCaptures_AsyncAction* Action = NewObject<UPICORequestSceneCaptures_AsyncAction>();
|
|
Action->SceneLoadInfo = InSceneLoadInfo;
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICORequestSceneCaptures_AsyncAction::HandleRequestSpatialSceneComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
TArray<FPICOMRSceneInfo> SceneLoadInfos;
|
|
if (PXR_SceneProvider::GetInstance()->GetSpatialSceneInfos(FutureHandle, SceneLoadInfos, Result))
|
|
{
|
|
OnSuccess.Broadcast(Result, SceneLoadInfos);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICORequestSceneCaptures_AsyncAction::HandleLoadSceneAnchorEntityComplete(EPICOResult Result, const TArray<FAnchorLoadResult>& AnchorLoadResults)
|
|
{
|
|
TArray<FPICOMRSceneInfo> MRSceneInfos;
|
|
if (PXR_SUCCESS(Result)
|
|
&& PXR_AnchorProvider::GetInstance()->GetSpatialAnchorSceneInfosLegacy(AnchorLoadResults, MRSceneInfos))
|
|
{
|
|
OnSuccess.Broadcast(Result, MRSceneInfos);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
UPICORequestSpatialMesh_AsyncAction* UPICORequestSpatialMesh_AsyncAction::PXR_RequestSpatialMeshInfos_Async()
|
|
{
|
|
UPICORequestSpatialMesh_AsyncAction* Action = NewObject<UPICORequestSpatialMesh_AsyncAction>();
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICORequestSpatialMesh_AsyncAction::HandleRequestSpatialMeshComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FQuat BaseOrientation = FPICOProviderManager::GetBaseOrientation();
|
|
FVector BaseOffsetInMeters = FPICOProviderManager::GetBaseOffsetInMeters();
|
|
float WorldToMetersScale = FPICOProviderManager::GetWorldToMetersScale();
|
|
FTransform TrackingToWorld=FPICOProviderManager::GetTrackingToWorldTransform();
|
|
AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [FutureHandle,TrackingToWorld,BaseOrientation,BaseOffsetInMeters,WorldToMetersScale,this]()
|
|
{
|
|
TArray<FPICOSpatialMeshInfo> MeshInfos;
|
|
TSet<FPICOSpatialUUID> NeedDeleteEntitySet;
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
if (PXR_MeshProvider::GetInstance()->GetSpatialTriangleMeshInfos(FutureHandle, TrackingToWorld,BaseOrientation, BaseOffsetInMeters, WorldToMetersScale, MeshInfos, Result))
|
|
{
|
|
OnSuccess.Broadcast(Result, MeshInfos);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
SetReadyToDestroy();
|
|
});
|
|
}
|
|
|
|
void UPICOLaunchSpatialMeshScanning_AsyncAction::Activate()
|
|
{
|
|
if(!PXR_MeshProvider::GetInstance()->IsHandleValid())
|
|
{
|
|
const UPICOXRSettings* Settings = GetDefault<UPICOXRSettings>();
|
|
if (Settings->bEnableMesh)
|
|
{
|
|
FPICOSenseDataProviderCreateInfoMesh cFPICOSenseDataProviderCreateInfoMesh = {};
|
|
cFPICOSenseDataProviderCreateInfoMesh.Lod = Settings->MeshLod;
|
|
if (Settings->bSemanticsAlignWithTriangle)
|
|
{
|
|
cFPICOSenseDataProviderCreateInfoMesh.ConfigArray.Add(EPICOSpatialMeshConfig::Spatial_Mesh_Config_Semantic);
|
|
}
|
|
else if (Settings->bSemanticsAlignWithVertex)
|
|
{
|
|
cFPICOSenseDataProviderCreateInfoMesh.ConfigArray.Add(EPICOSpatialMeshConfig::Spatial_Mesh_Config_Semantic);
|
|
cFPICOSenseDataProviderCreateInfoMesh.ConfigArray.Add(EPICOSpatialMeshConfig::Spatial_Mesh_Config_Semantic_Align_With_Vertex);
|
|
}
|
|
|
|
FPICOProviderManager::PXR_CreateSenseDataProvider(cFPICOSenseDataProviderCreateInfoMesh);
|
|
}
|
|
}
|
|
|
|
EPICOResult Result=EPICOResult::PXR_Error_Unknow;
|
|
const bool bStarted = FPICOProviderManager::PXR_StartSenseDataProviderAsync
|
|
(
|
|
FPICOPollFutureDelegate::CreateUObject(this,
|
|
&UPICOLaunchSpatialMeshScanning_AsyncAction::HandleLaunchMeshScanningComplete)
|
|
, EPICOProviderType::Pico_Provider_Mesh,Result
|
|
);
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICOLaunchSpatialMeshScanning_AsyncAction* UPICOLaunchSpatialMeshScanning_AsyncAction::PXR_LaunchSpatialMeshScanning_Async()
|
|
{
|
|
UPICOLaunchSpatialMeshScanning_AsyncAction* Action = NewObject<UPICOLaunchSpatialMeshScanning_AsyncAction>();
|
|
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOLaunchSpatialMeshScanning_AsyncAction::HandleLaunchMeshScanningComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSenseDataProviderStartCompletion SenseDataProviderStartCompletion;
|
|
EPICOResult OutResult=EPICOResult::PXR_Error_Unknow;
|
|
|
|
if(PXR_MeshProvider::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 UPICOLaunchSpatialAnchorService_AsyncAction::Activate()
|
|
{
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
OnSuccess.Broadcast(EPICOResult::PXR_Success);
|
|
return;
|
|
}
|
|
|
|
if(!PXR_AnchorProvider::GetInstance()->IsHandleValid())
|
|
{
|
|
const UPICOXRSettings* Settings = GetDefault<UPICOXRSettings>();
|
|
if (Settings->bEnableAnchor)
|
|
{
|
|
FPICOSenseDataProviderCreateInfoAnchor cFPICOSenseDataProviderCreateInfoAnchor = {};
|
|
FPICOProviderManager::PXR_CreateSenseDataProvider(cFPICOSenseDataProviderCreateInfoAnchor);
|
|
}
|
|
}
|
|
EPICOResult Result=EPICOResult::PXR_Error_Unknow;
|
|
const bool bStarted = FPICOProviderManager::PXR_StartSenseDataProviderAsync(
|
|
FPICOPollFutureDelegate::CreateUObject(this,&UPICOLaunchSpatialAnchorService_AsyncAction::HandleLaunchSpatialAnchorServiceComplete),
|
|
EPICOProviderType::Pico_Provider_Anchor,
|
|
Result
|
|
);
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICOLaunchSpatialAnchorService_AsyncAction* UPICOLaunchSpatialAnchorService_AsyncAction::PXR_LaunchSpatialAnchorService_Async()
|
|
{
|
|
UPICOLaunchSpatialAnchorService_AsyncAction* Action = NewObject<UPICOLaunchSpatialAnchorService_AsyncAction>();
|
|
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOLaunchSpatialAnchorService_AsyncAction::HandleLaunchSpatialAnchorServiceComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSenseDataProviderStartCompletion SenseDataProviderStartCompletion;
|
|
|
|
EPICOResult OutResult=EPICOResult::PXR_Error_Unknow;
|
|
|
|
if(PXR_AnchorProvider::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 UPICOLaunchSceneCaptureService_AsyncAction::Activate()
|
|
{
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
OnSuccess.Broadcast(EPICOResult::PXR_Success);
|
|
return;
|
|
}
|
|
|
|
if(!PXR_SceneProvider::GetInstance()->IsHandleValid())
|
|
{
|
|
const UPICOXRSettings* Settings = GetDefault<UPICOXRSettings>();
|
|
if (Settings->bEnableSceneCapture)
|
|
{
|
|
FPICOSenseDataProviderCreateInfoSceneCapture cSenseDataProviderCreateInfoSceneCapture = {};
|
|
FPICOProviderManager::PXR_CreateSenseDataProvider(cSenseDataProviderCreateInfoSceneCapture);
|
|
}
|
|
}
|
|
|
|
EPICOResult Result=EPICOResult::PXR_Error_Unknow;
|
|
|
|
const bool bStarted = FPICOProviderManager::PXR_StartSenseDataProviderAsync(
|
|
FPICOPollFutureDelegate::CreateUObject(this,
|
|
&UPICOLaunchSceneCaptureService_AsyncAction::HandleLaunchSceneCaptureServiceComplete)
|
|
, EPICOProviderType::Pico_Provider_Scene_Capture,Result);
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICOLaunchSceneCaptureService_AsyncAction* UPICOLaunchSceneCaptureService_AsyncAction::PXR_LaunchSceneCaptureService_Async()
|
|
{
|
|
UPICOLaunchSceneCaptureService_AsyncAction* Action = NewObject<UPICOLaunchSceneCaptureService_AsyncAction>();
|
|
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOLaunchSceneCaptureService_AsyncAction::HandleLaunchSceneCaptureServiceComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSenseDataProviderStartCompletion SenseDataProviderStartCompletion;
|
|
|
|
EPICOResult OutResult=EPICOResult::PXR_Error_Unknow;
|
|
|
|
if(PXR_SceneProvider::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 UPICOLaunchSceneCaptureApp_AsyncAction::HandleLaunchSceneCaptureAppComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSceneCaptureStartCompletion cPICOSceneCaptureStartCompletion;
|
|
PXR_SceneProvider::GetInstance()->StartSceneCaptureComplete(FutureHandle, cPICOSceneCaptureStartCompletion);
|
|
|
|
if (PXR_SUCCESS(cPICOSceneCaptureStartCompletion.FutureResult))
|
|
{
|
|
OnSuccess.Broadcast(cPICOSceneCaptureStartCompletion.FutureResult);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(cPICOSceneCaptureStartCompletion.FutureResult);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICOLaunchSceneCaptureApp_AsyncAction::HandleStartSpatialSceneCaptureComplete(EPICOResult Result, EPICOSpatialSceneCaptureStatus SpatialSceneCaptureStatus)
|
|
{
|
|
if (PXR_SUCCESS(Result))
|
|
{
|
|
OnSuccess.Broadcast(Result);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
UPICOLaunchSceneCaptureApp_AsyncAction* UPICOLaunchSceneCaptureApp_AsyncAction::PXR_LaunchSceneCaptureApp_Async()
|
|
{
|
|
UPICOLaunchSceneCaptureApp_AsyncAction* Action = NewObject<UPICOLaunchSceneCaptureApp_AsyncAction>();
|
|
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOLaunchSceneCaptureApp_AsyncAction::Activate()
|
|
{
|
|
bool bStarted =false;
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->StartSpatialSceneCapture(
|
|
FPICOStartSpatialSceneCaptureDelegate::CreateUObject(this, &UPICOLaunchSceneCaptureApp_AsyncAction::HandleStartSpatialSceneCaptureComplete),
|
|
Result
|
|
);
|
|
}
|
|
else
|
|
{
|
|
bStarted = PXR_SceneProvider::GetInstance()->StartSceneCaptureAsync
|
|
(
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICOLaunchSceneCaptureApp_AsyncAction::HandleLaunchSceneCaptureAppComplete),
|
|
Result
|
|
);
|
|
}
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Create Anchor Entity
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UPICOCreateSpatialAnchor_AsyncAction::Activate()
|
|
{
|
|
if (!IsValid(BoundActor) || !IsValid(BoundActor->GetWorld()))
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
return;
|
|
}
|
|
|
|
bool bStarted=false;
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->CreateAnchorEntityLegacy(
|
|
BoundActor,
|
|
SpatialAnchorTransform,
|
|
0,
|
|
FPICOCreateAnchorEntityDelegate::CreateUObject(this, &UPICOCreateSpatialAnchor_AsyncAction::HandleCreateAnchorEntityComplete),
|
|
Result
|
|
);
|
|
}
|
|
else
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->CreateSpatialAnchorAsync
|
|
(
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICOCreateSpatialAnchor_AsyncAction::HandleCreateSpatialAnchorComplete)
|
|
, SpatialAnchorTransform
|
|
,Result
|
|
);
|
|
}
|
|
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICOCreateSpatialAnchor_AsyncAction* UPICOCreateSpatialAnchor_AsyncAction::PXR_CreateSpatialAnchor_Async(AActor* BoundActor, const FTransform& InSpatialAnchorTransform)
|
|
{
|
|
UPICOCreateSpatialAnchor_AsyncAction* Action = NewObject<UPICOCreateSpatialAnchor_AsyncAction>();
|
|
Action->BoundActor = BoundActor;
|
|
Action->SpatialAnchorTransform = InSpatialAnchorTransform;
|
|
|
|
if (IsValid(BoundActor))
|
|
{
|
|
Action->RegisterWithGameInstance(BoundActor->GetWorld());
|
|
}
|
|
else
|
|
{
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
}
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOCreateSpatialAnchor_AsyncAction::HandleCreateSpatialAnchorComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSpatialAnchorCreateCompletion SpatialAnchorCreateCompletion;
|
|
EPICOResult OutResult=EPICOResult::PXR_Error_Unknow;
|
|
if(PXR_AnchorProvider::GetInstance()->CreateSpatialAnchorComplete(FutureHandle, SpatialAnchorCreateCompletion,OutResult))
|
|
{
|
|
UPICOAnchorComponent* AnchorComponent = Cast<UPICOAnchorComponent>(BoundActor->GetComponentByClass(UPICOAnchorComponent::StaticClass()));
|
|
if (!AnchorComponent)
|
|
{
|
|
AnchorComponent = Cast<UPICOAnchorComponent>(BoundActor->AddComponentByClass(UPICOAnchorComponent::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();
|
|
}
|
|
|
|
void UPICOCreateSpatialAnchor_AsyncAction::HandleCreateAnchorEntityComplete(EPICOResult Result,const UPICOAnchorComponent* AnchorComponent)
|
|
{
|
|
if (PXR_SUCCESS(Result))
|
|
{
|
|
OnSuccess.Broadcast(Result,AnchorComponent);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Persist Anchor Entity
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UPICOPersistSpatialAnchor_AsyncAction::Activate()
|
|
{
|
|
if (!IsValid(BoundActor))
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
return;
|
|
}
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
|
|
bool bStarted = false;
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->PersistAnchorEntityLegacy(
|
|
BoundActor,
|
|
PersistLocation,
|
|
FPICOPersistAnchorEntityDelegate::CreateUObject(this, &UPICOPersistSpatialAnchor_AsyncAction::HandlePersistAnchorEntityComplete),
|
|
Result
|
|
);
|
|
}
|
|
else
|
|
{
|
|
switch (PersistLocation)
|
|
{
|
|
case EPICOPersistLocation::PersistLocation_Local:
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->PersistSpatialAnchorAsync
|
|
(
|
|
BoundActor,
|
|
PersistLocation,
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICOPersistSpatialAnchor_AsyncAction::HandlePersistSpatialAnchorComplete),
|
|
Result
|
|
);
|
|
}
|
|
break;
|
|
case EPICOPersistLocation::PersistLocation_Shared:
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->ShareSpatialAnchorAsync
|
|
(
|
|
BoundActor,
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICOPersistSpatialAnchor_AsyncAction::HandleShareSpatialAnchorComplete),
|
|
Result
|
|
);
|
|
}
|
|
break;
|
|
default: ;
|
|
}
|
|
}
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICOPersistSpatialAnchor_AsyncAction* UPICOPersistSpatialAnchor_AsyncAction::PXR_PersistSpatialAnchor_Async(AActor* InBoundActor, EPICOPersistLocation InPersistLocation)
|
|
{
|
|
UPICOPersistSpatialAnchor_AsyncAction* Action = NewObject<UPICOPersistSpatialAnchor_AsyncAction>();
|
|
Action->BoundActor = InBoundActor;
|
|
Action->PersistLocation = InPersistLocation;
|
|
|
|
if (IsValid(InBoundActor))
|
|
{
|
|
Action->RegisterWithGameInstance(InBoundActor->GetWorld());
|
|
}
|
|
else
|
|
{
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
}
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOPersistSpatialAnchor_AsyncAction::HandlePersistSpatialAnchorComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSpatialAnchorPersistCompletion SpatialAnchorPersistCompletion;
|
|
EPICOResult OutResult=EPICOResult::PXR_Error_Unknow;
|
|
if (PXR_AnchorProvider::GetInstance()->PersistSpatialAnchorComplete(FutureHandle, SpatialAnchorPersistCompletion,OutResult))
|
|
{
|
|
UPICOAnchorComponent* AnchorComponent = Cast<UPICOAnchorComponent>(BoundActor->GetComponentByClass(UPICOAnchorComponent::StaticClass()));
|
|
if (IsValid(AnchorComponent) && AnchorComponent->IsAnchorValid())
|
|
{
|
|
if (PXR_SUCCESS(SpatialAnchorPersistCompletion.FutureResult))
|
|
{
|
|
OnSuccess.Broadcast(SpatialAnchorPersistCompletion.FutureResult,AnchorComponent);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(SpatialAnchorPersistCompletion.FutureResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(OutResult);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICOPersistSpatialAnchor_AsyncAction::HandleShareSpatialAnchorComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSpatialAnchorShareCompletion SpatialAnchorShareCompletion;
|
|
EPICOResult OutResult=EPICOResult::PXR_Error_Unknow;
|
|
if (PXR_AnchorProvider::GetInstance()->ShareSpatialAnchorComplete(FutureHandle, SpatialAnchorShareCompletion,OutResult))
|
|
{
|
|
UPICOAnchorComponent* AnchorComponent = Cast<UPICOAnchorComponent>(BoundActor->GetComponentByClass(UPICOAnchorComponent::StaticClass()));
|
|
if (IsValid(AnchorComponent) && AnchorComponent->IsAnchorValid())
|
|
{
|
|
if (PXR_SUCCESS(SpatialAnchorShareCompletion.FutureResult))
|
|
{
|
|
OnSuccess.Broadcast(SpatialAnchorShareCompletion.FutureResult,AnchorComponent);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(SpatialAnchorShareCompletion.FutureResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(OutResult);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICOPersistSpatialAnchor_AsyncAction::HandlePersistAnchorEntityComplete(EPICOResult Result, const UPICOAnchorComponent* AnchorComponent)
|
|
{
|
|
if (PXR_SUCCESS(Result))
|
|
{
|
|
OnSuccess.Broadcast(Result,AnchorComponent);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Unpersist Anchor Entity
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UPICOUnpersistSpatialAnchor_AsyncAction::Activate()
|
|
{
|
|
if (!IsValid(BoundActor))
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
return;
|
|
}
|
|
bool bStarted=false;
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->UnpersistAnchorEntityLegacy(
|
|
BoundActor,
|
|
PersistLocation,
|
|
FPICOUnpersistAnchorEntityDelegate::CreateUObject(this, &UPICOUnpersistSpatialAnchor_AsyncAction::HandleUnpersistAnchorEntityComplete),
|
|
Result
|
|
);
|
|
}
|
|
else
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->UnpersistSpatialAnchorAsync(
|
|
BoundActor,
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICOUnpersistSpatialAnchor_AsyncAction::HandleUnpersistSpatialAnchorComplete),
|
|
Result
|
|
);
|
|
}
|
|
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICOUnpersistSpatialAnchor_AsyncAction* UPICOUnpersistSpatialAnchor_AsyncAction::PXR_UnpersistSpatialAnchor_Async(AActor* BoundActor, EPICOPersistLocation InPersistLocation)
|
|
{
|
|
UPICOUnpersistSpatialAnchor_AsyncAction* Action = NewObject<UPICOUnpersistSpatialAnchor_AsyncAction>();
|
|
Action->BoundActor = BoundActor;
|
|
Action->PersistLocation = InPersistLocation;
|
|
|
|
if (IsValid(BoundActor))
|
|
{
|
|
Action->RegisterWithGameInstance(BoundActor->GetWorld());
|
|
}
|
|
else
|
|
{
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
}
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOUnpersistSpatialAnchor_AsyncAction::HandleUnpersistSpatialAnchorComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
FPICOSpatialAnchorUnpersistCompletion SpatialAnchorUnpersistCompletion;
|
|
EPICOResult OutResult=EPICOResult::PXR_Error_Unknow;
|
|
|
|
if(PXR_AnchorProvider::GetInstance()->UnpersistSpatialAnchorComplete(FutureHandle, SpatialAnchorUnpersistCompletion,OutResult))
|
|
{
|
|
UPICOAnchorComponent* AnchorComponent = Cast<UPICOAnchorComponent>(BoundActor->GetComponentByClass(UPICOAnchorComponent::StaticClass()));
|
|
if (IsValid(AnchorComponent) && AnchorComponent->IsAnchorValid())
|
|
{
|
|
if (PXR_SUCCESS(SpatialAnchorUnpersistCompletion.FutureResult))
|
|
{
|
|
OnSuccess.Broadcast(SpatialAnchorUnpersistCompletion.FutureResult,AnchorComponent);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(SpatialAnchorUnpersistCompletion.FutureResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(OutResult);
|
|
}
|
|
|
|
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICOUnpersistSpatialAnchor_AsyncAction::HandleUnpersistAnchorEntityComplete(EPICOResult Result, const UPICOAnchorComponent* AnchorComponent)
|
|
{
|
|
if (PXR_SUCCESS(Result))
|
|
{
|
|
OnSuccess.Broadcast(Result,AnchorComponent);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICOUploadSpatialAnchor_AsyncAction::Activate()
|
|
{
|
|
if (!IsValid(BoundActor))
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
return;
|
|
}
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
|
|
bool bStarted = false;
|
|
|
|
bStarted = PXR_AnchorProvider::GetInstance()->UploadSpatialAnchorAsync
|
|
(
|
|
BoundActor,
|
|
FPICOPollFutureWithProgressDelegate::CreateUObject(this, &UPICOUploadSpatialAnchor_AsyncAction::HandleUploadSpatialAnchorComplete),
|
|
Result
|
|
);
|
|
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICOUploadSpatialAnchor_AsyncAction* UPICOUploadSpatialAnchor_AsyncAction::PXR_UploadSpatialAnchor_Async(AActor* InBoundActor,const FPICOUploadProgress& InProgressEvent)
|
|
{
|
|
UPICOUploadSpatialAnchor_AsyncAction* Action = NewObject<UPICOUploadSpatialAnchor_AsyncAction>();
|
|
Action->BoundActor = InBoundActor;
|
|
Action->ProgressEvent=InProgressEvent;
|
|
if (IsValid(InBoundActor))
|
|
{
|
|
Action->RegisterWithGameInstance(InBoundActor->GetWorld());
|
|
}
|
|
else
|
|
{
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
}
|
|
|
|
return Action;
|
|
}
|
|
|
|
void UPICOUploadSpatialAnchor_AsyncAction::HandleUploadSpatialAnchorComplete(const FPICOSpatialHandle& FutureHandle,const int32 Progress,EFutureState State)
|
|
{
|
|
if (Progress)
|
|
{
|
|
if (Progress!=LastProgress)
|
|
{
|
|
ProgressEvent.ExecuteIfBound(Progress);
|
|
}
|
|
LastProgress=Progress;
|
|
}
|
|
|
|
if (State==EFutureState::Future_State_Ready_EXT)
|
|
{
|
|
FPICOSpatialAnchorShareCompletion SpatialAnchorShareCompletion;
|
|
EPICOResult OutResult = EPICOResult::PXR_Error_Unknow;
|
|
|
|
if (PXR_AnchorProvider::GetInstance()->ShareSpatialAnchorComplete(FutureHandle, SpatialAnchorShareCompletion,OutResult))
|
|
{
|
|
UPICOAnchorComponent* AnchorComponent = Cast<UPICOAnchorComponent>(BoundActor->GetComponentByClass(UPICOAnchorComponent::StaticClass()));
|
|
if (IsValid(AnchorComponent) && AnchorComponent->IsAnchorValid())
|
|
{
|
|
if (PXR_SUCCESS(SpatialAnchorShareCompletion.FutureResult))
|
|
{
|
|
OnSuccess.Broadcast(SpatialAnchorShareCompletion.FutureResult,AnchorComponent);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(SpatialAnchorShareCompletion.FutureResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(EPICOResult::PXR_Error_ValidationFailure);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(OutResult);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
}
|
|
|
|
void UPICODownloadSharedSpatialAnchor_AsyncAction::Activate()
|
|
{
|
|
bool bStarted = false;
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
bStarted = PXR_AnchorProvider::GetInstance()->DownloadSharedSpatialAnchorWithProgressAsync
|
|
(
|
|
UUID,
|
|
FPICOPollFutureWithProgressDelegate::CreateUObject(this,&UPICODownloadSharedSpatialAnchor_AsyncAction::HandleDownloadSharedAnchorWithProgressComplete),
|
|
Result
|
|
);
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
SetReadyToDestroy();
|
|
}
|
|
}
|
|
|
|
UPICODownloadSharedSpatialAnchor_AsyncAction* UPICODownloadSharedSpatialAnchor_AsyncAction::PXR_DownloadSharedSpatialAnchor(const FPICOSpatialUUID& InUUID, const FPICODownloadProgress& InProgressEvent)
|
|
{
|
|
UPICODownloadSharedSpatialAnchor_AsyncAction* Action = NewObject<UPICODownloadSharedSpatialAnchor_AsyncAction>();
|
|
Action->UUID = InUUID;
|
|
Action->ProgressEvent = InProgressEvent;
|
|
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
|
|
return Action;
|
|
}
|
|
|
|
|
|
void UPICODownloadSharedSpatialAnchor_AsyncAction::HandleDownloadSharedAnchorWithProgressComplete(const FPICOSpatialHandle& FutureHandle,const int32 Progress,EFutureState State)
|
|
{
|
|
if (Progress)
|
|
{
|
|
if (Progress!=LastProgress)
|
|
{
|
|
ProgressEvent.ExecuteIfBound(Progress,UUID);
|
|
}
|
|
LastProgress=Progress;
|
|
}
|
|
|
|
if (State==EFutureState::Future_State_Ready_EXT)
|
|
{
|
|
FPICOSharedSpatialAnchorDownloadCompletion SharedSpatialAnchorDownloadCompletion;
|
|
|
|
PXR_LOGV(PxrMR, "HandleDownloadSharedAnchorsComplete FutureHandle:%llu",FutureHandle.Value);
|
|
EPICOResult OutResult =EPICOResult::PXR_Error_Unknow;
|
|
|
|
if (PXR_AnchorProvider::GetInstance()->DownloadSharedSpatialAnchorsComplete(FutureHandle, SharedSpatialAnchorDownloadCompletion,OutResult))
|
|
{
|
|
if (PXR_SUCCESS(SharedSpatialAnchorDownloadCompletion.FutureResult))
|
|
{
|
|
OnSuccess.Broadcast(SharedSpatialAnchorDownloadCompletion.FutureResult);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(SharedSpatialAnchorDownloadCompletion.FutureResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(OutResult);
|
|
}
|
|
}
|
|
|
|
|
|
SetReadyToDestroy();
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Load Anchor Entity
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UPICORequestSpatialAnchors_AsyncAction::Activate()
|
|
{
|
|
bool bStarted = false;
|
|
EPICOResult Result = EPICOResult::PXR_Error_Unknow;
|
|
|
|
if (FPICOProviderManager::ShouldUseLegacyMR())
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->LoadAnchorEntityLegacy
|
|
(
|
|
EPICOLoadFilterType::LoadFilterType_UUID,
|
|
LoadInfo, FPICOSceneLoadInfo(),
|
|
FPICOLoadAnchorEntityDelegate::CreateUObject(this, &UPICORequestSpatialAnchors_AsyncAction::HandleLoadAnchorEntityComplete),
|
|
Result
|
|
);
|
|
}
|
|
else
|
|
{
|
|
FutureHandleSet.Empty();
|
|
switch (LoadInfo.PersistLocation)
|
|
{
|
|
case EPICOPersistLocation::PersistLocation_Local:
|
|
{
|
|
PXR_LOGV(PxrMR, "UPICORequestSpatialAnchors_AsyncAction Activate Start");
|
|
bStarted = PXR_AnchorProvider::GetInstance()->LoadAnchorEntityAsync
|
|
(
|
|
LoadInfo,
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICORequestSpatialAnchors_AsyncAction::HandleLoadSpatialAnchorsComplete),
|
|
Result
|
|
);
|
|
}
|
|
break;
|
|
case EPICOPersistLocation::PersistLocation_Shared:
|
|
{
|
|
bStarted = PXR_AnchorProvider::GetInstance()->DownloadSharedSpatialAnchorsAsync
|
|
(
|
|
LoadInfo,
|
|
FPICOPollFutureDelegate::CreateUObject(this,&UPICORequestSpatialAnchors_AsyncAction::HandleDownloadSharedAnchorsComplete),
|
|
FutureHandleSet,
|
|
Result
|
|
);
|
|
}
|
|
break;
|
|
default: ;
|
|
}
|
|
}
|
|
|
|
if (!bStarted)
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
}
|
|
|
|
UPICORequestSpatialAnchors_AsyncAction* UPICORequestSpatialAnchors_AsyncAction::PXR_LoadSpatialAnchor_Async(const FPICOAnchorLoadInfo& InLoadInfo)
|
|
{
|
|
UPICORequestSpatialAnchors_AsyncAction* Action = NewObject<UPICORequestSpatialAnchors_AsyncAction>();
|
|
Action->LoadInfo = InLoadInfo;
|
|
Action->RegisterWithGameInstance(GWorld);
|
|
return Action;
|
|
}
|
|
|
|
void UPICORequestSpatialAnchors_AsyncAction::HandleLoadSpatialAnchorsComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
EPICOResult LoadResult=EPICOResult::PXR_Error_Unknow;
|
|
|
|
TArray<FAnchorLoadResult> AnchorLoadResults;
|
|
PXR_LOGV(PxrMR, "HandleLoadSpatialAnchorsComplete Start");
|
|
|
|
PXR_AnchorProvider::GetInstance()->GetAnchorLoadResults(FutureHandle,AnchorLoadResults,LoadResult);
|
|
|
|
if (PXR_SUCCESS(LoadResult))
|
|
{
|
|
OnSuccess.Broadcast(LoadResult,AnchorLoadResults);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(LoadResult);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICORequestSpatialAnchors_AsyncAction::HandleDownloadSharedAnchorsComplete(const FPICOSpatialHandle& FutureHandle)
|
|
{
|
|
EPICOResult OutResult = EPICOResult::PXR_Error_Unknow;
|
|
FPICOSharedSpatialAnchorDownloadCompletion SharedSpatialAnchorDownloadCompletion;
|
|
FutureHandleSet.Remove(FutureHandle);
|
|
if(PXR_AnchorProvider::GetInstance()->DownloadSharedSpatialAnchorsComplete(FutureHandle, SharedSpatialAnchorDownloadCompletion,OutResult))
|
|
{
|
|
if(PXR_SUCCESS(SharedSpatialAnchorDownloadCompletion.FutureResult))
|
|
{
|
|
if (!FutureHandleSet.Num())
|
|
{
|
|
if(!PXR_AnchorProvider::GetInstance()->LoadAnchorEntityAsync(
|
|
LoadInfo,
|
|
FPICOPollFutureDelegate::CreateUObject(this, &UPICORequestSpatialAnchors_AsyncAction::HandleLoadSpatialAnchorsComplete),
|
|
OutResult
|
|
))
|
|
{
|
|
OnFailure.Broadcast(OutResult);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(SharedSpatialAnchorDownloadCompletion.FutureResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(OutResult);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|
|
|
|
void UPICORequestSpatialAnchors_AsyncAction::HandleLoadAnchorEntityComplete(EPICOResult Result, const TArray<FAnchorLoadResult>& AnchorLoadResults)
|
|
{
|
|
if (PXR_SUCCESS(Result))
|
|
{
|
|
OnSuccess.Broadcast(Result, AnchorLoadResults);
|
|
}
|
|
else
|
|
{
|
|
OnFailure.Broadcast(Result);
|
|
}
|
|
|
|
SetReadyToDestroy();
|
|
}
|