ARGeoTrackingSupport.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "ARBlueprintProxy.h"
#include "Misc/Optional.h"
#include "ARTypes.h"
#include "Features/IModularFeature.h"
 
#include "ARGeoTrackingSupport.generated.h"
 
#define UE_API AUGMENTEDREALITY_API
 
 
class FCheckGeoTrackingAvailabilityAsyncTask;
class FGetGeoLocationAsyncTask;
 
 
UENUM(BlueprintType)
enum class EARGeoTrackingState : uint8
{
    // The session is initializing geo tracking.
    Initializing,
    
    // Geo tracking is localized.
    Localized,
    
    // Geo tracking is attempting to localize against a map.
    Localizing,
    
    // Geo tracking is not available.
    NotAvailable,
};
 
 
UENUM(BlueprintType)
enum class EARGeoTrackingStateReason : uint8
{
    // No issues reported.
    None,
    
    // Geo tracking is not available at the location.
    NotAvailableAtLocation,
    
    // Geo tracking needs location permissions from the user.
    NeedLocationPermissions,
    
    // The user is pointing the device too low to use geo tracking.
    DevicePointedTooLow,
    
    // The session is unsure of the device’s pose in the physical environment.
    WorldTrackingUnstable,
    
    // The framework is waiting for a position for the user.
    WaitingForLocation,
    
    // The framework is actively attempting to download localization imagery.
    GeoDataNotLoaded,
    
    // The framework failed to match its localization imagery with the device’s camera captures.
    VisualLocalizationFailed,
    
    // The framework is waiting for the availability check.
    WaitingForAvailabilityCheck,
};
 
 
UENUM(BlueprintType)
enum class EARGeoTrackingAccuracy : uint8
{
    // Geo-tracking accuracy is undetermined.
    Undetermined,
    
    // Geo-tracking accuracy is low.
    Low,
    
    // Geo-tracking accuracy is average.
    Medium,
    
    // Geo-tracking accuracy is high.
    High,
};
 
 
UCLASS(MinimalAPI, BlueprintType, Abstract, Category="AR|Geo Tracking")
class UARGeoTrackingSupport : public UObject, public IModularFeature
{
    GENERATED_BODY()
    
public:
    static FName GetModularFeatureName()
    {
        static FName FeatureName = FName(TEXT("ARGeoTrackingSupport"));
        return FeatureName;
    }
    
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking")
    static UE_API class UARGeoTrackingSupport* GetGeoTrackingSupport();
    
    UE_API virtual TSharedPtr<FCheckGeoTrackingAvailabilityAsyncTask, ESPMode::ThreadSafe> CheckGeoTrackingAvailability(FString& OutError);
    
    UE_API virtual TSharedPtr<FCheckGeoTrackingAvailabilityAsyncTask, ESPMode::ThreadSafe> CheckGeoTrackingAvailability(float Longitude, float Latitude, FString& OutError);
    
    UE_API virtual TSharedPtr<FGetGeoLocationAsyncTask, ESPMode::ThreadSafe> GetGeoLocationAtWorldPosition(const FVector& WorldPosition, FString& OutError);
    
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking")
    virtual EARGeoTrackingState GetGeoTrackingState() const { return EARGeoTrackingState::NotAvailable; }
    
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking")
    virtual EARGeoTrackingStateReason GetGeoTrackingStateReason() const { return EARGeoTrackingStateReason::NotAvailableAtLocation; }
    
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking")
    virtual EARGeoTrackingAccuracy GetGeoTrackingAccuracy() const { return EARGeoTrackingAccuracy::Undetermined; }
    
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking")
    virtual bool AddGeoAnchorAtLocation(float Longitude, float Latitude, FString OptionalAnchorName) { return false; }
    
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking")
    virtual bool AddGeoAnchorAtLocationWithAltitude(float Longitude, float Latitude, float AltitudeMeters, FString OptionalAnchorName) { return false; }
};
 
 
class FCheckGeoTrackingAvailabilityAsyncTask : public FARAsyncTask
{
public:
    bool IsAvailable() const { return bIsAvailable; }
    
    UE_API void FinishWithAvailability(bool bInIsAvailable);
    
    UE_API void FinishWithError(const FString& InError);
    
private:
    bool bIsAvailable = false;
};
 
 
UCLASS(MinimalAPI)
class UCheckGeoTrackingAvailabilityAsyncTaskBlueprintProxy : public UARBaseAsyncTaskBlueprintProxy
{
    GENERATED_BODY()
    
public:
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FGeoTrackingAvailabilityDelegate, bool, bIsAvailable, FString, Error);
    
    UPROPERTY(BlueprintAssignable)
    FGeoTrackingAvailabilityDelegate OnSuccess;
    
    UPROPERTY(BlueprintAssignable)
    FGeoTrackingAvailabilityDelegate OnFailed;
 
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking", meta=(BlueprintInternalUseOnly="true", WorldContext = "WorldContextObject"))
    static UE_API UCheckGeoTrackingAvailabilityAsyncTaskBlueprintProxy* CheckGeoTrackingAvailability(UObject* WorldContextObject);
    
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking", meta=(BlueprintInternalUseOnly="true", WorldContext = "WorldContextObject"))
    static UE_API UCheckGeoTrackingAvailabilityAsyncTaskBlueprintProxy* CheckGeoTrackingAvailabilityAtLocation(UObject* WorldContextObject, float Longitude, float Latitude);
    
private:
    // UBlueprintAsyncActionBase interface
    UE_API void Activate() override;
    UE_API void ReportSuccess() override;
    UE_API void ReportFailure() override;
    //~UBlueprintAsyncActionBase interface
    
    TOptional<float> Longitude;
    TOptional<float> Latitude;
    
    TSharedPtr<FCheckGeoTrackingAvailabilityAsyncTask, ESPMode::ThreadSafe> MyTask;
    
    FString Error;
};
 
 
class FGetGeoLocationAsyncTask : public FARAsyncTask
{
public:
    UE_API void FinishWithGeoLocation(float InLongitude, float InLatitude, float InAltitude);
    
    UE_API void FinishWithError(const FString& InError);
    
    float GetLongitude() const { return Longitude; }
    
    float GetLatitude() const { return Latitude; }
    
    float GetAltitude() const { return Altitude; }
    
private:
    float Longitude = 0.f;
    float Latitude = 0.f;
    float Altitude = 0.f;
};
 
 
UCLASS(MinimalAPI)
class UGetGeoLocationAsyncTaskBlueprintProxy : public UARBaseAsyncTaskBlueprintProxy
{
    GENERATED_BODY()
    
public:
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FGetGeoLocationDelegate, float, Longitude, float, Latitude, float, Altitude, FString, Error);
    
    UPROPERTY(BlueprintAssignable)
    FGetGeoLocationDelegate OnSuccess;
    
    UPROPERTY(BlueprintAssignable)
    FGetGeoLocationDelegate OnFailed;
 
    UFUNCTION(BlueprintCallable, Category = "AR AugmentedReality|Geo Tracking", meta=(BlueprintInternalUseOnly="true", WorldContext = "WorldContextObject"))
    static UE_API UGetGeoLocationAsyncTaskBlueprintProxy* GetGeoLocationAtWorldPosition(UObject* WorldContextObject, const FVector& WorldPosition);
    
private:
    // UBlueprintAsyncActionBase interface
    UE_API void Activate() override;
    UE_API void ReportSuccess() override;
    UE_API void ReportFailure() override;
    //~UBlueprintAsyncActionBase interface
    
    FVector WorldPosition = FVector::ZeroVector;
    
    TSharedPtr<FGetGeoLocationAsyncTask, ESPMode::ThreadSafe> MyTask;
    
    FString Error;
};
 
#undef UE_API