IXRTrackingSystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "HeadMountedDisplayTypes.h"
#include "IIdentifiableXRDevice.h"
#include "UObject/ObjectMacros.h"
#include "Features/IModularFeature.h"
#include "StereoRendering.h"
 
class IXRCamera;
class UARPin;
class FSceneViewFamily;
struct FWorldContext;
class FARSupportInterface;
class IOpenXRHMD;
 
struct FXRSensorProperties
{
    float LeftFOV;
    float RightFOV;
    float TopFOV;
    float BottomFOV;
    float NearPlane; 
    float FarPlane;
 
    float CameraDistance;
};
 
 
 
class  IXRTrackingSystem : public IModularFeature, public IXRSystemIdentifier
{
public:
    static FName GetModularFeatureName()
    {
        static const FName FeatureName = FName(TEXT("XRTrackingSystem"));
        return FeatureName;
    }
 
    virtual FString GetVersionString() const = 0;
 
    virtual int32 GetXRSystemFlags() const = 0;
 
    static constexpr int32 HMDDeviceId = 0;
 
    virtual bool DoesSupportPositionalTracking() const = 0;
 
    virtual bool DoesSupportLateUpdate() const { return true; }
 
    virtual bool DoesSupportLateProjectionUpdate() const { return false; }
 
    virtual bool HasValidTrackingPosition() = 0;
 
    virtual bool EnumerateTrackedDevices(TArray<int32>& OutDevices, EXRTrackedDeviceType Type = EXRTrackedDeviceType::Any) = 0;
 
    virtual uint32 CountTrackedDevices(EXRTrackedDeviceType Type = EXRTrackedDeviceType::Any) = 0;
 
    virtual bool IsTracking(int32 DeviceId) = 0;
 
    virtual void RebaseObjectOrientationAndPosition(FVector& Position, FQuat& Orientation) const {};
 
    virtual bool GetCurrentPose(int32 DeviceId, FQuat& OutOrientation, FVector& OutPosition) = 0;
 
    virtual bool GetRelativeEyePose(int32 DeviceId, int32 ViewIndex, FQuat& OutOrientation, FVector& OutPosition) = 0;
 
    virtual bool GetTrackingSensorProperties(int32 DeviceId, FQuat& OutOrientation, FVector& OutPosition, FXRSensorProperties& OutSensorProperties) = 0;
 
    virtual EXRTrackedDeviceType GetTrackedDeviceType(int32 DeviceId) const = 0;
 
    virtual FString GetTrackedDevicePropertySerialNumber(int32 DeviceId) = 0;
 
    virtual void SetTrackingOrigin(EHMDTrackingOrigin::Type NewOrigin) = 0;
 
    virtual EHMDTrackingOrigin::Type GetTrackingOrigin() const = 0;
 
    virtual FTransform GetTrackingToWorldTransform() const = 0;
 
    virtual float GetWorldToMetersScale() const = 0;
 
    virtual bool GetFloorToEyeTrackingTransform(FTransform& OutFloorToEye) const = 0;
 
    virtual void UpdateTrackingToWorldTransform(const FTransform& TrackingToWorldOverride) = 0;
 
    virtual FVector GetAudioListenerOffset(int32 DeviceId = HMDDeviceId) const { return FVector::ZeroVector; }
 
    virtual void ResetOrientationAndPosition(float Yaw = 0.f) = 0;
 
    virtual void ResetOrientation(float Yaw = 0.f) {}
 
    virtual void ResetPosition() {}
 
    virtual void SetBaseRotation(const FRotator& BaseRot) {}
 
    virtual FRotator GetBaseRotation() const { return FRotator::ZeroRotator; }
 
    virtual void SetBaseOrientation(const FQuat& BaseOrient) {}
 
    virtual FQuat GetBaseOrientation() const { return FQuat::Identity; }
 
    virtual void SetBasePosition(const FVector& BasePosition) {};
 
    virtual FVector GetBasePosition() const { return FVector::ZeroVector; }
 
    virtual void CalibrateExternalTrackingSource(const FTransform& ExternalTrackingTransform) {}
 
    virtual void UpdateExternalTrackingPosition(const FTransform& ExternalTrackingTransform) {}
 
    virtual class TSharedPtr< class IXRCamera, ESPMode::ThreadSafe > GetXRCamera(int32 DeviceId = HMDDeviceId) = 0;
 
    virtual class IHeadMountedDisplay* GetHMDDevice() { return nullptr; }
 
    virtual class TSharedPtr< class IStereoRendering, ESPMode::ThreadSafe > GetStereoRenderingDevice()
    {
        check(GetHMDDevice() == nullptr);
        return nullptr; 
    }
 
    UE_DEPRECATED(5.6, "IXRInput is deprecated and will be removed in a future release.")
    virtual class IXRInput* GetXRInput() { return nullptr; }
 
 
    virtual TSharedPtr<FARSupportInterface, ESPMode::ThreadSafe> GetARCompositionComponent() { return nullptr; }
    virtual const TSharedPtr<const FARSupportInterface, ESPMode::ThreadSafe> GetARCompositionComponent() const { return nullptr; }
 
 
    virtual class IXRLoadingScreen* GetLoadingScreen() { return nullptr; }
 
    /*** XR System related methods moved from IHeadMountedDisplay ***/
 
    virtual bool IsHeadTrackingAllowed() const = 0;
 
    HEADMOUNTEDDISPLAY_API virtual bool IsHeadTrackingAllowedForWorld(UWorld & World) const;
 
    virtual bool IsHeadTrackingEnforced() const { return false; }
 
    virtual void SetHeadTrackingEnforced(bool bEnabled) {};
 
 
    virtual void OnBeginPlay(FWorldContext& InWorldContext) {}
 
    virtual void OnEndPlay(FWorldContext& InWorldContext) {}
 
    virtual bool OnStartGameFrame(FWorldContext& WorldContext) { return false; }
 
    virtual bool OnEndGameFrame(FWorldContext& WorldContext) { return false; }
 
 
    /*** Methods designed to be called from IXRCamera implementations ***/
 
    UE_DEPRECATED(5.6, "Use the FRDGBuilder overload instead")
    virtual void OnBeginRendering_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneViewFamily& ViewFamily) final {}
    HEADMOUNTEDDISPLAY_API virtual void OnBeginRendering_RenderThread(FRDGBuilder& GraphBuilder, FSceneViewFamily& ViewFamily);
 
    UE_DEPRECATED(5.6, "Use the FSceneViewFamily overload instead")
    virtual void OnBeginRendering_GameThread() final {}
    virtual void OnBeginRendering_GameThread(FSceneViewFamily& InViewFamily)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        OnBeginRendering_GameThread();
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.6, "Use the FRDGBuilder overload instead")
    virtual void OnLateUpdateApplied_RenderThread(FRHICommandListImmediate& RHICmdList, const FTransform& NewRelativeTransform) final {}
    HEADMOUNTEDDISPLAY_API virtual void OnLateUpdateApplied_RenderThread(FRDGBuilder& GraphBuilder, const FTransform& NewRelativeTransform);
 
    HEADMOUNTEDDISPLAY_API virtual void GetHMDData(UObject* WorldContext, FXRHMDData& HMDData);
 
    virtual void GetMotionControllerState(UObject* WorldContext, const EXRSpaceType XRSpaceType, const EControllerHand Hand, const EXRControllerPoseType XRControllerPoseType, FXRMotionControllerState& MotionControllerState) = 0;
    virtual void GetHandTrackingState(UObject* WorldContext, const EXRSpaceType XRSpaceType, const EControllerHand Hand, FXRHandTrackingState& HandTrackingState) = 0;
    virtual bool GetCurrentInteractionProfile(const EControllerHand Hand, FString& InteractionProfile) = 0;
 
    virtual EXRDeviceConnectionResult::Type ConnectRemoteXRDevice(const FString& IpAddress, const int32 BitRate)
    { 
        return EXRDeviceConnectionResult::FeatureNotSupported;
    }
    virtual void DisconnectRemoteXRDevice() {}
 
    virtual FVector2D GetPlayAreaBounds(EHMDTrackingOrigin::Type Origin) const { return FVector2D::ZeroVector; }
 
    virtual bool GetTrackingOriginTransform(TEnumAsByte<EHMDTrackingOrigin::Type> Origin, FTransform& OutTransform) const { return false; }
 
    virtual bool GetPlayAreaRect(FTransform& OutTransform, FVector2D& OutRect) const { return false; }
 
    virtual IOpenXRHMD* GetIOpenXRHMD() { return nullptr; }
};