VRTowerDef/Plugins/MetaXR/Source/OculusXRHMD/Private/OculusXRHMD.cpp

// @lint-ignore-every LICENSELINT
// Copyright Epic Games, Inc. All Rights Reserved.

#include "OculusXRHMD.h"
#include "OculusXRHMDPrivateRHI.h"

#include "EngineAnalytics.h"
#include "Interfaces/IAnalyticsProvider.h"
#include "AnalyticsEventAttribute.h"
#include "Slate/SceneViewport.h"
#include "PostProcess/PostProcessHMD.h"
#include "PostProcess/SceneRenderTargets.h"
#include "HardwareInfo.h"
#include "ScreenRendering.h"
#include "GameFramework/PlayerController.h"
#include "Math/UnrealMathUtility.h"
#include "Math/TranslationMatrix.h"
#include "Widgets/SViewport.h"
#include "Layout/WidgetPath.h"
#include "Framework/Application/SlateApplication.h"
#include "Engine/Canvas.h"
#include "Engine/GameEngine.h"
#include "Engine/RendererSettings.h"
#include "Misc/CoreDelegates.h"
#include "GameFramework/WorldSettings.h"
#include "Engine/StaticMesh.h"
#include "Engine/StaticMeshActor.h"
#include "Components/InstancedStaticMeshComponent.h"
#include "Misc/EngineVersion.h"
#include "ClearQuad.h"
#include "DynamicResolutionState.h"
#include "DynamicResolutionProxy.h"
#include "OculusXRHMDRuntimeSettings.h"
#include "OculusXRDelegates.h"
#include "DataDrivenShaderPlatformInfo.h"
#include "GenericPlatform/GenericPlatformMath.h"
#include "LegacyScreenPercentageDriver.h"

#if PLATFORM_ANDROID
#include "Android/AndroidJNI.h"
#include "Android/AndroidApplication.h"
#include "HAL/IConsoleManager.h"
#include "AndroidPermissionFunctionLibrary.h"
#include "AndroidPermissionCallbackProxy.h"
#endif
#include "OculusShaders.h"
#include "PipelineStateCache.h"

#include "IOculusXRMRModule.h"

#if WITH_EDITOR
#include "Editor/UnrealEd/Classes/Editor/EditorEngine.h"
#include "Settings/LevelEditorPlaySettings.h"
#endif

#if !UE_BUILD_SHIPPING
#include "Debug/DebugDrawService.h"
#endif

#if OCULUS_HMD_SUPPORTED_PLATFORMS

static TAutoConsoleVariable<int32> CVarOculusEnableSubsampledLayout(
	TEXT("r.Mobile.Oculus.EnableSubsampled"),
	0,
	TEXT("0: Disable subsampled layout (Default)\n")
		TEXT("1: Enable subsampled layout on supported platforms\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

static TAutoConsoleVariable<int32> CVarOculusEnableLowLatencyVRS(
	TEXT("r.Mobile.Oculus.EnableLowLatencyVRS"),
	0,
	TEXT("0: Disable late update of VRS textures (Default)\n")
		TEXT("1: Enable late update of VRS textures\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

static TAutoConsoleVariable<int32> CVarOculusForceSymmetric(
	TEXT("r.Mobile.Oculus.ForceSymmetric"),
	0,
	TEXT("0: Use standard runtime-provided projection matrices (Default)\n")
		TEXT("1: Render both eyes with a symmetric projection, union of both FOVs (and corresponding higher rendertarget size to maintain PD)\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

// AppSpaceWarp
static TAutoConsoleVariable<int32> CVarOculusEnableSpaceWarpUser(
	TEXT("r.Mobile.Oculus.SpaceWarp.Enable"),
	0,
	TEXT("0 Disable spacewarp at runtime.\n")
		TEXT("1 Enable spacewarp at runtime.\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

static TAutoConsoleVariable<int32> CVarOculusEnableSpaceWarpInternal(
	TEXT("r.Mobile.Oculus.SpaceWarp.EnableInternal"),
	0,
	TEXT("0 Disable spacewarp, for internal engine checking, don't modify.\n")
		TEXT("1 Enable spacewarp, for internal enegine checking, don't modify.\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

// Foveated Rendering
static TAutoConsoleVariable<int32> CVarOculusFoveatedRenderingMethod(
	TEXT("r.Mobile.Oculus.FoveatedRendering.Method"),
	-1,
	TEXT("0 Fixed Foveated Rendering.\n")
		TEXT("1 Eye-Tracked Foveated Rendering.\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

static TAutoConsoleVariable<int32> CVarOculusFoveatedRenderingLevel(
	TEXT("r.Mobile.Oculus.FoveatedRendering.Level"),
	-1,
	TEXT("0 Off.\n")
		TEXT("1 Low.\n")
			TEXT("2 Medium.\n")
				TEXT("3 High.\n")
					TEXT("4 High Top.\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

static TAutoConsoleVariable<int32> CVarOculusDynamicFoveatedRendering(
	TEXT("r.Mobile.Oculus.FoveatedRendering.Dynamic"),
	-1,
	TEXT("0 Disable Dynamic Foveated Rendering at runtime.\n")
		TEXT("1 Enable Dynamic Foveated Rendering at runtime.\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

static TAutoConsoleVariable<float> CVarOculusDynamicResolutionPixelDensity(
	TEXT("r.Oculus.DynamicResolution.PixelDensity"),
	0,
	TEXT("0 Static Pixel Density corresponding to Pixel Density 1.0 (default)\n")
		TEXT(">0 Manual Pixel Density Override\n"),
	ECVF_Scalability | ECVF_RenderThreadSafe);

#define OCULUS_PAUSED_IDLE_FPS 10

static const FString USE_SCENE_PERMISSION_NAME("com.oculus.permission.USE_SCENE");

namespace OculusXRHMD
{

#if !UE_BUILD_SHIPPING
	static void __cdecl OvrpLogCallback(ovrpLogLevel level, const char* message)
	{
		FString tbuf = ANSI_TO_TCHAR(message);
		const TCHAR* levelStr = TEXT("");
		switch (level)
		{
			case ovrpLogLevel_Debug:
				levelStr = TEXT(" Debug:");
				break;
			case ovrpLogLevel_Info:
				levelStr = TEXT(" Info:");
				break;
			case ovrpLogLevel_Error:
				levelStr = TEXT(" Error:");
				break;
		}

		GLog->Logf(TEXT("OCULUS:%s %s"), levelStr, *tbuf);
	}
#endif // !UE_BUILD_SHIPPING

	//-------------------------------------------------------------------------------------------------
	// FOculusXRHMD
	//-------------------------------------------------------------------------------------------------

	const FName FOculusXRHMD::OculusSystemName(TEXT("OculusXRHMD"));

	FName FOculusXRHMD::GetSystemName() const
	{
		return OculusSystemName;
	}
	int32 FOculusXRHMD::GetXRSystemFlags() const
	{
		return EXRSystemFlags::IsHeadMounted;
	}

	FString FOculusXRHMD::GetVersionString() const
	{
		const char* Version;

		if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetVersion2(&Version)))
		{
			Version = "Unknown";
		}

		return FString::Printf(TEXT("OVRPlugin: %s"), UTF8_TO_TCHAR(Version));
	}

	bool FOculusXRHMD::DoesSupportPositionalTracking() const
	{
		ovrpBool trackingPositionSupported;
		return OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetTrackingPositionSupported2(&trackingPositionSupported)) && trackingPositionSupported;
	}

	bool FOculusXRHMD::HasValidTrackingPosition()
	{
		ovrpBool nodePositionTracked;
		return OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetNodePositionTracked2(ovrpNode_Head, &nodePositionTracked)) && nodePositionTracked;
	}

	struct TrackedDevice
	{
		ovrpNode Node;
		EXRTrackedDeviceType Type;
	};

	static TrackedDevice TrackedDevices[] = {
		{ ovrpNode_Head, EXRTrackedDeviceType::HeadMountedDisplay },
		{ ovrpNode_HandLeft, EXRTrackedDeviceType::Controller },
		{ ovrpNode_HandRight, EXRTrackedDeviceType::Controller },
		{ ovrpNode_TrackerZero, EXRTrackedDeviceType::TrackingReference },
		{ ovrpNode_TrackerOne, EXRTrackedDeviceType::TrackingReference },
		{ ovrpNode_TrackerTwo, EXRTrackedDeviceType::TrackingReference },
		{ ovrpNode_TrackerThree, EXRTrackedDeviceType::TrackingReference },
		{ ovrpNode_DeviceObjectZero, EXRTrackedDeviceType::Other },
	};

	static uint32 TrackedDeviceCount = sizeof(TrackedDevices) / sizeof(TrackedDevices[0]);

	bool FOculusXRHMD::EnumerateTrackedDevices(TArray<int32>& OutDevices, EXRTrackedDeviceType Type)
	{
		CheckInGameThread();

		for (uint32 TrackedDeviceId = 0; TrackedDeviceId < TrackedDeviceCount; TrackedDeviceId++)
		{
			if (Type == EXRTrackedDeviceType::Any || Type == TrackedDevices[TrackedDeviceId].Type)
			{
				ovrpBool nodePresent;

				ovrpNode Node = TrackedDevices[TrackedDeviceId].Node;
				if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetNodePresent2(Node, &nodePresent)) && nodePresent)
				{
					const int32 ExternalDeviceId = OculusXRHMD::ToExternalDeviceId(Node);
					OutDevices.Add(ExternalDeviceId);
				}
			}
		}

		return true;
	}

	void FOculusXRHMD::UpdateRTPoses()
	{
		CheckInRenderThread();
		FGameFrame* CurrentFrame = GetFrame_RenderThread();
		if (CurrentFrame)
		{
			if (!CurrentFrame->Flags.bRTLateUpdateDone)
			{
				FOculusXRHMDModule::GetPluginWrapper().Update3(ovrpStep_Render, CurrentFrame->FrameNumber, 0.0);
				CurrentFrame->Flags.bRTLateUpdateDone = true;
			}
		}
		// else, Frame_RenderThread has already been reset/rendered (or not created yet).
		// This can happen when DoEnableStereo() is called, as SetViewportSize (which it calls) enques a render
		// immediately - meaning two render frames were enqueued in the span of one game tick.
	}

	bool FOculusXRHMD::GetCurrentPose(int32 InDeviceId, FQuat& OutOrientation, FVector& OutPosition)
	{
		OutOrientation = FQuat::Identity;
		OutPosition = FVector::ZeroVector;

		if ((size_t)InDeviceId >= TrackedDeviceCount)
		{
			return false;
		}

		ovrpNode Node = OculusXRHMD::ToOvrpNode(InDeviceId);
		const FSettings* CurrentSettings;
		FGameFrame* CurrentFrame;

		if (InRenderThread())
		{
			CurrentSettings = GetSettings_RenderThread();
			CurrentFrame = GetFrame_RenderThread();
			UpdateRTPoses();
		}
		else if (InGameThread())
		{
			CurrentSettings = GetSettings();
			CurrentFrame = NextFrameToRender.Get();
		}
		else
		{
			return false;
		}

		if (!CurrentSettings || !CurrentFrame)
		{
			return false;
		}

		ovrpPoseStatef PoseState;
		FPose Pose;

		if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetNodePoseState3(ovrpStep_Render, CurrentFrame->FrameNumber, Node, &PoseState)) || !ConvertPose_Internal(PoseState.Pose, Pose, CurrentSettings, CurrentFrame->WorldToMetersScale))
		{
			return false;
		}

		OutPosition = Pose.Position;
		OutOrientation = Pose.Orientation;
		return true;
	}

	bool FOculusXRHMD::GetRelativeEyePose(int32 InDeviceId, int32 ViewIndex, FQuat& OutOrientation, FVector& OutPosition)
	{
		OutOrientation = FQuat::Identity;
		OutPosition = FVector::ZeroVector;

		if (InDeviceId != HMDDeviceId)
		{
			return false;
		}

		ovrpNode Node;

		switch (ViewIndex)
		{
			case EStereoscopicEye::eSSE_LEFT_EYE:
				Node = ovrpNode_EyeLeft;
				break;
			case EStereoscopicEye::eSSE_RIGHT_EYE:
				Node = ovrpNode_EyeRight;
				break;
			case EStereoscopicEye::eSSE_MONOSCOPIC:
				Node = ovrpNode_EyeCenter;
				break;
			default:
				return false;
		}

		const FSettings* CurrentSettings;
		FGameFrame* CurrentFrame;

		if (InRenderThread())
		{
			CurrentSettings = GetSettings_RenderThread();
			CurrentFrame = GetFrame_RenderThread();
			UpdateRTPoses();
		}
		else if (InGameThread())
		{
			CurrentSettings = GetSettings();
			CurrentFrame = NextFrameToRender.Get();
		}
		else
		{
			return false;
		}

		if (!CurrentSettings || !CurrentFrame)
		{
			return false;
		}

		ovrpPoseStatef HmdPoseState, EyePoseState;

		if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetNodePoseState3(ovrpStep_Render, CurrentFrame->FrameNumber, ovrpNode_Head, &HmdPoseState)) || OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetNodePoseState3(ovrpStep_Render, CurrentFrame->FrameNumber, Node, &EyePoseState)))
		{
			return false;
		}

		FPose HmdPose, EyePose;
		HmdPose.Orientation = ToFQuat(HmdPoseState.Pose.Orientation);
		HmdPose.Position = ToFVector(HmdPoseState.Pose.Position) * CurrentFrame->WorldToMetersScale;
		EyePose.Orientation = ToFQuat(EyePoseState.Pose.Orientation);
		EyePose.Position = ToFVector(EyePoseState.Pose.Position) * CurrentFrame->WorldToMetersScale;

		FQuat HmdOrientationInv = HmdPose.Orientation.Inverse();
		OutOrientation = HmdOrientationInv * EyePose.Orientation;
		OutOrientation.Normalize();
		OutPosition = HmdOrientationInv.RotateVector(EyePose.Position - HmdPose.Position);
		return true;
	}

	bool FOculusXRHMD::GetTrackingSensorProperties(int32 InDeviceId, FQuat& OutOrientation, FVector& OutPosition, FXRSensorProperties& OutSensorProperties)
	{
		CheckInGameThread();

		if ((size_t)InDeviceId >= TrackedDeviceCount)
		{
			return false;
		}

		ovrpNode Node = OculusXRHMD::ToOvrpNode(InDeviceId);
		ovrpPoseStatef PoseState;
		FPose Pose;
		ovrpFrustum2f Frustum;

		if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetNodePoseState3(ovrpStep_Render, OVRP_CURRENT_FRAMEINDEX, Node, &PoseState)) || !ConvertPose(PoseState.Pose, Pose) || OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetNodeFrustum2(Node, &Frustum)))
		{
			return false;
		}

		OutPosition = Pose.Position;
		OutOrientation = Pose.Orientation;
		OutSensorProperties.LeftFOV = FMath::RadiansToDegrees(FMath::Atan(Frustum.Fov.LeftTan));
		OutSensorProperties.RightFOV = FMath::RadiansToDegrees(FMath::Atan(Frustum.Fov.RightTan));
		OutSensorProperties.TopFOV = FMath::RadiansToDegrees(FMath::Atan(Frustum.Fov.UpTan));
		OutSensorProperties.BottomFOV = FMath::RadiansToDegrees(FMath::Atan(Frustum.Fov.DownTan));
		OutSensorProperties.NearPlane = Frustum.zNear * Frame->WorldToMetersScale;
		OutSensorProperties.FarPlane = Frustum.zFar * Frame->WorldToMetersScale;
		OutSensorProperties.CameraDistance = 1.0f * Frame->WorldToMetersScale;
		return true;
	}

	void FOculusXRHMD::SetTrackingOrigin(EHMDTrackingOrigin::Type InOrigin)
	{
		TrackingOrigin = InOrigin;
		ovrpTrackingOrigin ovrpOrigin = ovrpTrackingOrigin_EyeLevel;
		if (InOrigin == EHMDTrackingOrigin::Floor)
			ovrpOrigin = ovrpTrackingOrigin_FloorLevel;

		if (InOrigin == EHMDTrackingOrigin::Stage)
			ovrpOrigin = ovrpTrackingOrigin_Stage;

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized())
		{
			EHMDTrackingOrigin::Type lastOrigin = GetTrackingOrigin();
			FOculusXRHMDModule::GetPluginWrapper().SetTrackingOriginType2(ovrpOrigin);
			OCFlags.NeedSetTrackingOrigin = false;

			if (lastOrigin != InOrigin)
				Settings->BaseOffset = FVector::ZeroVector;
		}

		OnTrackingOriginChanged();
	}

	EHMDTrackingOrigin::Type FOculusXRHMD::GetTrackingOrigin() const
	{
		EHMDTrackingOrigin::Type rv = EHMDTrackingOrigin::Eye;
		ovrpTrackingOrigin ovrpOrigin = ovrpTrackingOrigin_EyeLevel;

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized() && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetTrackingOriginType2(&ovrpOrigin)))
		{
			switch (ovrpOrigin)
			{
				case ovrpTrackingOrigin_EyeLevel:
					rv = EHMDTrackingOrigin::Eye;
					break;
				case ovrpTrackingOrigin_FloorLevel:
					rv = EHMDTrackingOrigin::Floor;
					break;
				case ovrpTrackingOrigin_Stage:
					rv = EHMDTrackingOrigin::Stage;
					break;
				default:
					UE_LOG(LogHMD, Error, TEXT("Unsupported ovr tracking origin type %d"), int(ovrpOrigin));
					break;
			}
		}
		return rv;
	}

	bool FOculusXRHMD::GetFloorToEyeTrackingTransform(FTransform& OutFloorToEye) const
	{
		float EyeHeight = 0.f;
		const bool bSuccess = FOculusXRHMDModule::GetPluginWrapper().GetInitialized() && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetUserEyeHeight2(&EyeHeight));
		OutFloorToEye = FTransform(FVector(0.f, 0.f, -ConvertFloat_M2U(EyeHeight)));

		return bSuccess;
	}

	void FOculusXRHMD::ResetOrientationAndPosition(float yaw)
	{
		Recenter(RecenterOrientationAndPosition, yaw);
	}

	void FOculusXRHMD::ResetOrientation(float yaw)
	{
		Recenter(RecenterOrientation, yaw);
	}

	void FOculusXRHMD::ResetPosition()
	{
		Recenter(RecenterPosition, 0);
	}

	void FOculusXRHMD::Recenter(FRecenterTypes RecenterType, float Yaw)
	{
		CheckInGameThread();

		if (NextFrameToRender)
		{
			const bool floorLevel = GetTrackingOrigin() != EHMDTrackingOrigin::Eye;
			ovrpPoseStatef poseState;
			FOculusXRHMDModule::GetPluginWrapper().Update3(ovrpStep_Render, NextFrameToRender->FrameNumber, 0.0);
			FOculusXRHMDModule::GetPluginWrapper().GetNodePoseState3(ovrpStep_Render, NextFrameToRender->FrameNumber, ovrpNode_Head, &poseState);

			if (RecenterType & RecenterPosition)
			{
				Settings->BaseOffset = ToFVector(poseState.Pose.Position);
				if (floorLevel)
					Settings->BaseOffset.Z = 0;
			}

			if (RecenterType & RecenterOrientation)
			{
				Settings->BaseOrientation = FRotator(0, FRotator(ToFQuat(poseState.Pose.Orientation)).Yaw - Yaw, 0).Quaternion();
			}
		}
	}

	void FOculusXRHMD::SetBaseRotation(const FRotator& BaseRot)
	{
		SetBaseOrientation(BaseRot.Quaternion());
	}

	FRotator FOculusXRHMD::GetBaseRotation() const
	{
		return GetBaseOrientation().Rotator();
	}

	void FOculusXRHMD::SetBaseOrientation(const FQuat& BaseOrient)
	{
		CheckInGameThread();

		Settings->BaseOrientation = BaseOrient;
	}

	FQuat FOculusXRHMD::GetBaseOrientation() const
	{
		CheckInGameThread();

		return Settings->BaseOrientation;
	}

	bool FOculusXRHMD::IsHeadTrackingEnforced() const
	{
		if (IsInGameThread())
		{
			return Settings.IsValid() && Settings->Flags.bHeadTrackingEnforced;
		}
		else
		{
			CheckInRenderThread();
			return Settings_RenderThread.IsValid() && Settings_RenderThread->Flags.bHeadTrackingEnforced;
		}
	}

	void FOculusXRHMD::SetHeadTrackingEnforced(bool bEnabled)
	{
		CheckInGameThread();
		check(Settings.IsValid());

		const bool bOldValue = Settings->Flags.bHeadTrackingEnforced;
		Settings->Flags.bHeadTrackingEnforced = bEnabled;

		if (!bEnabled)
		{
			ResetControlRotation();
		}
		else if (!bOldValue)
		{
			InitDevice();
		}
	}

	bool FOculusXRHMD::IsHeadTrackingAllowed() const
	{
		bool bNeedEnableStereo = false;
		CheckInGameThread();

		if (!FOculusXRHMDModule::GetPluginWrapper().GetInitialized())
		{
			return false;
		}

#if PLATFORM_WINDOWS
		// TODO: This is a temp fix of the case that callers wants to use IsHeadTrackingAllowed() to do something in UGameEngine::Start().
		//  Settings->Flags.bStereoEnabled won't be true until Window.IsValid() and UGameEngine::Tick() starts which is very late.
		//  We might need a better mechanism to decouple Window.IsValid() and Settings->Flags.bStereoEnabled.
		bNeedEnableStereo = !GIsEditor && Flags.bNeedEnableStereo;
#endif
		return (FHeadMountedDisplayBase::IsHeadTrackingAllowed() || bNeedEnableStereo);
	}

	void FOculusXRHMD::OnBeginPlay(FWorldContext& InWorldContext)
	{
		CheckInGameThread();

		CachedViewportWidget.Reset();
		CachedWindow.Reset();

		bHardOcclusionsEnabled = false;

#if WITH_EDITOR
		// @TODO: add more values here.
		// This call make sense when 'Play' is used from the Editor;
		if (GIsEditor && !GEnableVREditorHacks)
		{
			Settings->BaseOrientation = FQuat::Identity;
			Settings->BaseOffset = FVector::ZeroVector;
			Settings->ColorScale = ovrpVector4f{ 1, 1, 1, 1 };
			Settings->ColorOffset = ovrpVector4f{ 0, 0, 0, 0 };

			//Settings->WorldToMetersScale = InWorldContext.World()->GetWorldSettings()->WorldToMeters;
			//Settings->Flags.bWorldToMetersOverride = false;
			InitDevice();

			FApp::SetUseVRFocus(true);
			FApp::SetHasVRFocus(true);
			OnStartGameFrame(InWorldContext);
		}
#endif
	}

	void FOculusXRHMD::OnEndPlay(FWorldContext& InWorldContext)
	{
		CheckInGameThread();

#if WITH_EDITOR
		if (GIsEditor && !GEnableVREditorHacks)
		{
			// @todo vreditor: If we add support for starting PIE while in VR Editor, we don't want to kill stereo mode when exiting PIE
			if (Splash->IsShown())
			{
				Splash->HideLoadingScreen();			  // This will only request hiding the screen
				Splash->UpdateLoadingScreen_GameThread(); // Update is needed to complete removing the loading screen
			}
			EnableStereo(false);
			ReleaseDevice();

			FApp::SetUseVRFocus(false);
			FApp::SetHasVRFocus(false);
		}
#endif
	}

	DECLARE_STATS_GROUP(TEXT("Oculus System Metrics"), STATGROUP_OculusSystemMetrics, STATCAT_Advanced);

	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("App CPU Time (ms)"), STAT_OculusSystem_AppCpuTime, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("App GPU Time (ms)"), STAT_OculusSystem_AppGpuTime, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("Compositor CPU Time (ms)"), STAT_OculusSystem_ComCpuTime, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("Compositor GPU Time (ms)"), STAT_OculusSystem_ComGpuTime, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Compositor Dropped Frames"), STAT_OculusSystem_DroppedFrames, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("System GPU Util %"), STAT_OculusSystem_GpuUtil, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("System CPU Util Avg %"), STAT_OculusSystem_CpuUtilAvg, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("System CPU Util Worst %"), STAT_OculusSystem_CpuUtilWorst, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("CPU Clock Freq (MHz)"), STAT_OculusSystem_CpuFreq, STATGROUP_OculusSystemMetrics, );
	DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("GPU Clock Freq (MHz)"), STAT_OculusSystem_GpuFreq, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Clock Level"), STAT_OculusSystem_CpuClockLvl, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("GPU Clock Level"), STAT_OculusSystem_GpuClockLvl, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("SpaceWarp Mode"), STAT_OculusSystem_ComSpaceWarpMode, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core0 Util %"), STAT_OculusSystem_CpuCore0Util, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core1 Util %"), STAT_OculusSystem_CpuCore1Util, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core2 Util %"), STAT_OculusSystem_CpuCore2Util, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core3 Util %"), STAT_OculusSystem_CpuCore3Util, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core4 Util %"), STAT_OculusSystem_CpuCore4Util, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core5 Util %"), STAT_OculusSystem_CpuCore5Util, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core6 Util %"), STAT_OculusSystem_CpuCore6Util, STATGROUP_OculusSystemMetrics, );
	DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("CPU Core7 Util %"), STAT_OculusSystem_CpuCore7Util, STATGROUP_OculusSystemMetrics, );

	DEFINE_STAT(STAT_OculusSystem_AppCpuTime);
	DEFINE_STAT(STAT_OculusSystem_AppGpuTime);
	DEFINE_STAT(STAT_OculusSystem_ComCpuTime);
	DEFINE_STAT(STAT_OculusSystem_ComGpuTime);
	DEFINE_STAT(STAT_OculusSystem_DroppedFrames);
	DEFINE_STAT(STAT_OculusSystem_GpuUtil);
	DEFINE_STAT(STAT_OculusSystem_CpuUtilAvg);
	DEFINE_STAT(STAT_OculusSystem_CpuUtilWorst);
	DEFINE_STAT(STAT_OculusSystem_CpuFreq);
	DEFINE_STAT(STAT_OculusSystem_GpuFreq);
	DEFINE_STAT(STAT_OculusSystem_CpuClockLvl);
	DEFINE_STAT(STAT_OculusSystem_GpuClockLvl);
	DEFINE_STAT(STAT_OculusSystem_ComSpaceWarpMode);
	DEFINE_STAT(STAT_OculusSystem_CpuCore0Util);
	DEFINE_STAT(STAT_OculusSystem_CpuCore1Util);
	DEFINE_STAT(STAT_OculusSystem_CpuCore2Util);
	DEFINE_STAT(STAT_OculusSystem_CpuCore3Util);
	DEFINE_STAT(STAT_OculusSystem_CpuCore4Util);
	DEFINE_STAT(STAT_OculusSystem_CpuCore5Util);
	DEFINE_STAT(STAT_OculusSystem_CpuCore6Util);
	DEFINE_STAT(STAT_OculusSystem_CpuCore7Util);

	void UpdateOculusSystemMetricsStats()
	{
		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized() == ovrpBool_False)
		{
			return;
		}

		ovrpBool bIsSupported;
		float valueFloat = 0;
		int valueInt = 0;
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_App_CpuTime_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_App_CpuTime_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_AppCpuTime, valueFloat * 1000);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_App_GpuTime_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_App_GpuTime_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_AppGpuTime, valueFloat * 1000);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Compositor_CpuTime_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Compositor_CpuTime_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_ComCpuTime, valueFloat * 1000);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Compositor_GpuTime_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Compositor_GpuTime_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_ComGpuTime, valueFloat * 1000);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Compositor_DroppedFrameCount_Int, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsInt(ovrpPerfMetrics_Compositor_DroppedFrameCount_Int, &valueInt)))
			{
				SET_DWORD_STAT(STAT_OculusSystem_DroppedFrames, valueInt);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_System_GpuUtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_System_GpuUtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_GpuUtil, valueFloat * 100);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_System_CpuUtilAveragePercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_System_CpuUtilAveragePercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuUtilAvg, valueFloat * 100);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_System_CpuUtilWorstPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_System_CpuUtilWorstPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuUtilWorst, valueFloat * 100);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuClockFrequencyInMHz_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuClockFrequencyInMHz_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuFreq, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_GpuClockFrequencyInMHz_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_GpuClockFrequencyInMHz_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_GpuFreq, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuClockLevel_Int, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsInt(ovrpPerfMetrics_Device_CpuClockLevel_Int, &valueInt)))
			{
				SET_DWORD_STAT(STAT_OculusSystem_CpuClockLvl, valueInt);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_GpuClockLevel_Int, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsInt(ovrpPerfMetrics_Device_GpuClockLevel_Int, &valueInt)))
			{
				SET_DWORD_STAT(STAT_OculusSystem_GpuClockLvl, valueInt);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Compositor_SpaceWarp_Mode_Int, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsInt(ovrpPerfMetrics_Compositor_SpaceWarp_Mode_Int, &valueInt)))
			{
				SET_DWORD_STAT(STAT_OculusSystem_ComSpaceWarpMode, valueInt);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore0UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore0UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore0Util, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore1UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore1UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore1Util, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore2UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore2UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore2Util, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore3UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore3UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore3Util, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore4UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore4UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore4Util, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore5UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore5UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore5Util, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore6UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore6UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore6Util, valueFloat);
			}
		}
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().IsPerfMetricsSupported(ovrpPerfMetrics_Device_CpuCore7UtilPercentage_Float, &bIsSupported)) && bIsSupported == ovrpBool_True)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetPerfMetricsFloat(ovrpPerfMetrics_Device_CpuCore7UtilPercentage_Float, &valueFloat)))
			{
				SET_FLOAT_STAT(STAT_OculusSystem_CpuCore7Util, valueFloat);
			}
		}
	}

	void FOculusXRHMD::OnBeginRendering_GameThread()
	{
		CheckInGameThread();
		// We need to make sure we keep the Wait/Begin/End triplet in sync, so here we signal that we
		// can wait for the next frame in the next tick. Without this signal it's possible that two ticks
		// happen before the next frame is actually rendered.
		bShouldWait_GameThread = true;
	}

	bool FOculusXRHMD::OnStartGameFrame(FWorldContext& InWorldContext)
	{
#if WITH_EDITOR
		// In the editor there can be multiple worlds.  An editor world, pie worlds, other viewport worlds for editor pages.
		// XR hardware can only be running with one of them.
		if (GIsEditor && GEditor && GEditor->GetPIEWorldContext() != nullptr)
		{
			if (!InWorldContext.bIsPrimaryPIEInstance)
			{
				return false;
			}
		}
#endif // WITH_EDITOR

		CheckInGameThread();

		if (IsEngineExitRequested())
		{
			return false;
		}

		UpdateOculusSystemMetricsStats();

		RefreshTrackingToWorldTransform(InWorldContext);

		// check if HMD is marked as invalid and needs to be killed.
		ovrpBool appShouldRecreateDistortionWindow;

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized() && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetAppShouldRecreateDistortionWindow2(&appShouldRecreateDistortionWindow)) && appShouldRecreateDistortionWindow)
		{
			DoEnableStereo(false);
			ReleaseDevice();

			if (!OCFlags.DisplayLostDetected)
			{
				FCoreDelegates::VRHeadsetLost.Broadcast();
				OCFlags.DisplayLostDetected = true;
			}

			Flags.bNeedEnableStereo = true;
		}
#if PLATFORM_ANDROID
		Flags.bNeedEnableStereo = true; // !!!
#endif

		check(Settings.IsValid());
		if (!Settings->IsStereoEnabled())
		{
			FApp::SetUseVRFocus(false);
			FApp::SetHasVRFocus(false);
		}

#if OCULUS_STRESS_TESTS_ENABLED
		FStressTester::TickCPU_GameThread(this);
#endif

		if (bShutdownRequestQueued)
		{
			bShutdownRequestQueued = false;
			DoSessionShutdown();
		}

		if (!InWorldContext.World() || (!(GEnableVREditorHacks && InWorldContext.WorldType == EWorldType::Editor) && !InWorldContext.World()->IsGameWorld())) // @todo vreditor: (Also see OnEndGameFrame()) Kind of a hack here so we can use VR in editor viewports.  We need to consider when running GameWorld viewports inside the editor with VR.
		{
			// ignore all non-game worlds
			return false;
		}

		bool bStereoEnabled = Settings->Flags.bStereoEnabled;
		bool bStereoDesired = bStereoEnabled;

		if (Flags.bNeedEnableStereo)
		{
			bStereoDesired = true;
		}

		if (bStereoDesired && (Flags.bNeedDisableStereo || !Settings->Flags.bHMDEnabled))
		{
			bStereoDesired = false;
		}

		bool bStereoDesiredAndIsConnected = bStereoDesired;

		if (bStereoDesired && !(bStereoEnabled ? IsHMDActive() : IsHMDEnabled()))
		{
			bStereoDesiredAndIsConnected = false;
		}

		Flags.bNeedEnableStereo = false;
		Flags.bNeedDisableStereo = false;

		if (bStereoEnabled != bStereoDesiredAndIsConnected)
		{
			bStereoEnabled = DoEnableStereo(bStereoDesiredAndIsConnected);
		}

		// Keep trying to enable stereo until we succeed
		Flags.bNeedEnableStereo = bStereoDesired && !bStereoEnabled;

		if (!Settings->IsStereoEnabled() && !Settings->Flags.bHeadTrackingEnforced)
		{
			return false;
		}

		if (Flags.bApplySystemOverridesOnStereo)
		{
			ApplySystemOverridesOnStereo();
			Flags.bApplySystemOverridesOnStereo = false;
		}

		CachedWorldToMetersScale = InWorldContext.World()->GetWorldSettings()->WorldToMeters;

		// this should have already happened in FOculusXRInput, so this is usually a no-op.
		StartGameFrame_GameThread();

		bool retval = true;

		UpdateHMDEvents();

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized())
		{
			if (OCFlags.DisplayLostDetected)
			{
				FCoreDelegates::VRHeadsetReconnected.Broadcast();
				OCFlags.DisplayLostDetected = false;
			}

			if (OCFlags.NeedSetTrackingOrigin)
			{
				SetTrackingOrigin(TrackingOrigin);
			}

			ovrpBool bAppHasVRFocus = ovrpBool_False;
			FOculusXRHMDModule::GetPluginWrapper().GetAppHasVrFocus2(&bAppHasVRFocus);

			FApp::SetUseVRFocus(true);
			FApp::SetHasVRFocus(bAppHasVRFocus != ovrpBool_False);

			// Do not pause if Editor is running (otherwise it will become very laggy)
			if (!GIsEditor)
			{
				if (!bAppHasVRFocus)
				{
					// not visible,
					if (!Settings->Flags.bPauseRendering)
					{
						UE_LOG(LogHMD, Log, TEXT("The app went out of VR focus, seizing rendering..."));
					}
				}
				else if (Settings->Flags.bPauseRendering)
				{
					UE_LOG(LogHMD, Log, TEXT("The app got VR focus, restoring rendering..."));
				}
				if (OCFlags.NeedSetFocusToGameViewport)
				{
					if (bAppHasVRFocus)
					{
						UE_LOG(LogHMD, Log, TEXT("Setting user focus to game viewport since session status is visible..."));
						FSlateApplication::Get().SetAllUserFocusToGameViewport();
						OCFlags.NeedSetFocusToGameViewport = false;
					}
				}

				bool bPrevPause = Settings->Flags.bPauseRendering;
				Settings->Flags.bPauseRendering = !bAppHasVRFocus;

				if (Settings->Flags.bPauseRendering && (GEngine->GetMaxFPS() != OCULUS_PAUSED_IDLE_FPS))
				{
					GEngine->SetMaxFPS(OCULUS_PAUSED_IDLE_FPS);
				}

				if (bPrevPause != Settings->Flags.bPauseRendering)
				{
					APlayerController* const PC = GEngine->GetFirstLocalPlayerController(InWorldContext.World());
					if (Settings->Flags.bPauseRendering)
					{
						// focus is lost
						GEngine->SetMaxFPS(OCULUS_PAUSED_IDLE_FPS);

						if (!FCoreDelegates::ApplicationWillEnterBackgroundDelegate.IsBound())
						{
							OCFlags.AppIsPaused = false;
							// default action: set pause if not already paused
							if (PC && !PC->IsPaused())
							{
								PC->SetPause(true);
								OCFlags.AppIsPaused = true;
							}
						}
						else
						{
							FCoreDelegates::ApplicationWillEnterBackgroundDelegate.Broadcast();
						}
					}
					else
					{
						// focus is gained
						GEngine->SetMaxFPS(0);

						if (!FCoreDelegates::ApplicationHasEnteredForegroundDelegate.IsBound())
						{
							// default action: unpause if was paused by the plugin
							if (PC && OCFlags.AppIsPaused)
							{
								PC->SetPause(false);
							}
							OCFlags.AppIsPaused = false;
						}
						else
						{
							FCoreDelegates::ApplicationHasEnteredForegroundDelegate.Broadcast();
						}
					}
				}
			}

			ovrpBool AppShouldQuit;
			ovrpBool AppShouldRecenter;

			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetAppShouldQuit2(&AppShouldQuit)) && AppShouldQuit || OCFlags.EnforceExit)
			{
				FPlatformMisc::LowLevelOutputDebugString(TEXT("OculusXRHMD plugin requested exit (ShouldQuit == 1)\n"));
#if WITH_EDITOR
				if (GIsEditor)
				{
					FSceneViewport* SceneVP = FindSceneViewport();
					if (SceneVP && SceneVP->IsStereoRenderingAllowed())
					{
						TSharedPtr<SWindow> Window = SceneVP->FindWindow();
						Window->RequestDestroyWindow();
					}
				}
				else
#endif //WITH_EDITOR
				{
					// ApplicationWillTerminateDelegate will fire from inside of the RequestExit
					FPlatformMisc::RequestExit(false);
				}
				OCFlags.EnforceExit = false;
				retval = false;
			}
			else if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetAppShouldRecenter2(&AppShouldRecenter)) && AppShouldRecenter)
			{
				FPlatformMisc::LowLevelOutputDebugString(TEXT("OculusXRHMD plugin was requested to recenter\n"));
				if (FCoreDelegates::VRHeadsetRecenter.IsBound())
				{
					FCoreDelegates::VRHeadsetRecenter.Broadcast();
				}
				else
				{
					ResetOrientationAndPosition();
				}

				// Call FOculusXRHMDModule::GetPluginWrapper().RecenterTrackingOrigin2 to clear AppShouldRecenter flag
				FOculusXRHMDModule::GetPluginWrapper().RecenterTrackingOrigin2(ovrpRecenterFlag_IgnoreAll);
			}

			UpdateHMDWornState();
		}

#if OCULUS_MR_SUPPORTED_PLATFORMS
		if (FOculusXRHMDModule::GetPluginWrapper().GetMixedRealityInitialized())
		{
			FOculusXRHMDModule::GetPluginWrapper().UpdateExternalCamera();
		}
#endif

		if (IsEngineExitRequested())
		{
			PreShutdown();
		}

		return retval;
	}

	void FOculusXRHMD::DoSessionShutdown()
	{
		// Release resources
		ExecuteOnRenderThread([this]() {
			ExecuteOnRHIThread([this]() {
				for (int32 LayerIndex = 0; LayerIndex < Layers_RenderThread.Num(); LayerIndex++)
				{
					Layers_RenderThread[LayerIndex]->ReleaseResources_RHIThread();
				}

				for (int32 LayerIndex = 0; LayerIndex < Layers_RHIThread.Num(); LayerIndex++)
				{
					Layers_RHIThread[LayerIndex]->ReleaseResources_RHIThread();
				}

				if (Splash.IsValid())
				{
					Splash->ReleaseResources_RHIThread();
				}

				if (CustomPresent)
				{
					CustomPresent->ReleaseResources_RHIThread();
				}

				Settings_RHIThread.Reset();
				Frame_RHIThread.Reset();
				Layers_RHIThread.Reset();
			});

			Settings_RenderThread.Reset();
			Frame_RenderThread.Reset();
			Layers_RenderThread.Reset();
			EyeLayer_RenderThread.Reset();

			DeferredDeletion.HandleLayerDeferredDeletionQueue_RenderThread(true);

			EnableInsightPassthrough_RenderThread(false);
		});

		Frame.Reset();
		NextFrameToRender.Reset();
		LastFrameToRender.Reset();

#if !UE_BUILD_SHIPPING
		UDebugDrawService::Unregister(DrawDebugDelegateHandle);
#endif

		// The Editor may release VR focus in OnEndPlay
		if (!GIsEditor)
		{
			FApp::SetUseVRFocus(false);
			FApp::SetHasVRFocus(false);
		}

		ShutdownSession();
	}

	bool FOculusXRHMD::OnEndGameFrame(FWorldContext& InWorldContext)
	{
		CheckInGameThread();

		FGameFrame* const CurrentGameFrame = Frame.Get();

		if (CurrentGameFrame)
		{
			// don't use the cached value, as it could be affected by the player's position, so we update it here at the latest point in the game frame
			CurrentGameFrame->TrackingToWorld = ComputeTrackingToWorldTransform(InWorldContext);
			CurrentGameFrame->LastTrackingToWorld = LastTrackingToWorld;
			LastTrackingToWorld = CurrentGameFrame->TrackingToWorld;
		}
		else
		{
			return false;
		}

		if (!InWorldContext.World() || (!(GEnableVREditorHacks && InWorldContext.WorldType == EWorldType::Editor) && !InWorldContext.World()->IsGameWorld()))
		{
			// ignore all non-game worlds
			return false;
		}

		FinishGameFrame_GameThread();

		return true;
	}

	FVector2D FOculusXRHMD::GetPlayAreaBounds(EHMDTrackingOrigin::Type Origin) const
	{
		ovrpVector3f Dimensions;

		if (Origin == EHMDTrackingOrigin::Stage && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetBoundaryDimensions2(ovrpBoundary_PlayArea, &Dimensions)))
		{
			Dimensions.z *= -1.0;
			FVector Bounds = ConvertVector_M2U(Dimensions);
			return FVector2D(Bounds.X, Bounds.Z);
		}
		return FVector2D::ZeroVector;
	}

	bool FOculusXRHMD::IsHMDEnabled() const
	{
		CheckInGameThread();

		return (Settings->Flags.bHMDEnabled);
	}

	EHMDWornState::Type FOculusXRHMD::GetHMDWornState()
	{
		ovrpBool userPresent;

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized() && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetUserPresent2(&userPresent)) && userPresent)
		{
			return EHMDWornState::Worn;
		}
		else
		{
			return EHMDWornState::NotWorn;
		}
	}

	void FOculusXRHMD::EnableHMD(bool enable)
	{
		CheckInGameThread();

		Settings->Flags.bHMDEnabled = enable;
		if (!Settings->Flags.bHMDEnabled)
		{
			EnableStereo(false);
		}
	}

	bool FOculusXRHMD::GetHMDMonitorInfo(MonitorInfo& MonitorDesc)
	{
		CheckInGameThread();

		MonitorDesc.MonitorName = FString("Oculus Window");
		MonitorDesc.MonitorId = 0;
		MonitorDesc.DesktopX = MonitorDesc.DesktopY = 0;
		MonitorDesc.ResolutionX = MonitorDesc.ResolutionY = 0;
		MonitorDesc.WindowSizeX = MonitorDesc.WindowSizeY = 0;

		if (Settings.IsValid())
		{
			MonitorDesc.ResolutionX = MonitorDesc.WindowSizeX = Settings->RenderTargetSize.X;
			MonitorDesc.ResolutionY = MonitorDesc.WindowSizeY = Settings->RenderTargetSize.Y;
		}

		return true;
	}

	void FOculusXRHMD::GetFieldOfView(float& InOutHFOVInDegrees, float& InOutVFOVInDegrees) const

	{
		ovrpFrustum2f Frustum;

		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetNodeFrustum2(ovrpNode_EyeCenter, &Frustum)))
		{
			InOutVFOVInDegrees = FMath::RadiansToDegrees(FMath::Atan(Frustum.Fov.UpTan) + FMath::Atan(Frustum.Fov.DownTan));
			InOutHFOVInDegrees = FMath::RadiansToDegrees(FMath::Atan(Frustum.Fov.LeftTan) + FMath::Atan(Frustum.Fov.RightTan));
		}
	}

	void FOculusXRHMD::SetInterpupillaryDistance(float NewInterpupillaryDistance)
	{
		CheckInGameThread();

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized())
		{
			FOculusXRHMDModule::GetPluginWrapper().SetUserIPD2(NewInterpupillaryDistance);
		}
	}

	float FOculusXRHMD::GetInterpupillaryDistance() const
	{
		CheckInGameThread();

		float UserIPD;

		if (!FOculusXRHMDModule::GetPluginWrapper().GetInitialized() || OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetUserIPD2(&UserIPD)))
		{
			return 0.0f;
		}

		return UserIPD;
	}

	bool FOculusXRHMD::GetHMDDistortionEnabled(EShadingPath /* ShadingPath */) const
	{
		return false;
	}

	bool FOculusXRHMD::IsChromaAbCorrectionEnabled() const
	{
		CheckInGameThread();

		return true;
	}

	bool FOculusXRHMD::HasHiddenAreaMesh() const
	{
		if (IsInParallelRenderingThread())
		{
			if (ShouldDisableHiddenAndVisibileAreaMeshForSpectatorScreen_RenderThread())
			{
				return false;
			}
		}

		return HiddenAreaMeshes[0].IsValid() && HiddenAreaMeshes[1].IsValid();
	}

	bool FOculusXRHMD::HasVisibleAreaMesh() const
	{
		if (IsInParallelRenderingThread())
		{
			if (ShouldDisableHiddenAndVisibileAreaMeshForSpectatorScreen_RenderThread())
			{
				return false;
			}
		}

		return VisibleAreaMeshes[0].IsValid() && VisibleAreaMeshes[1].IsValid();
	}

	static void DrawOcclusionMesh(FRHICommandList& RHICmdList, int32 ViewIndex, const FHMDViewMesh MeshAssets[])
	{
		check(ViewIndex != INDEX_NONE);

		const uint32 MeshIndex = (ViewIndex == EStereoscopicEye::eSSE_LEFT_EYE) ? 0 : 1;
		const FHMDViewMesh& Mesh = MeshAssets[MeshIndex];
		check(Mesh.IsValid());

		RHICmdList.SetStreamSource(0, Mesh.VertexBufferRHI, 0);
		RHICmdList.DrawIndexedPrimitive(Mesh.IndexBufferRHI, 0, 0, Mesh.NumVertices, 0, Mesh.NumTriangles, 1);
	}

	void FOculusXRHMD::DrawHiddenAreaMesh(FRHICommandList& RHICmdList, int32 ViewIndex) const
	{
		DrawOcclusionMesh(RHICmdList, ViewIndex, HiddenAreaMeshes);
	}

	void FOculusXRHMD::DrawVisibleAreaMesh(FRHICommandList& RHICmdList, int32 ViewIndex) const
	{
		DrawOcclusionMesh(RHICmdList, ViewIndex, VisibleAreaMeshes);
	}

	float FOculusXRHMD::GetPixelDenity() const
	{
		if (IsInGameThread())
		{
			return Settings.IsValid() ? Settings->PixelDensity : 1.0f;
		}
		else
		{
			return Settings_RenderThread.IsValid() ? Settings_RenderThread->PixelDensity : 1.0f;
		}
	}

	void FOculusXRHMD::SetPixelDensity(const float NewPixelDensity)
	{
		CheckInGameThread();
		Settings->SetPixelDensity(NewPixelDensity);
	}

	FIntPoint FOculusXRHMD::GetIdealRenderTargetSize() const
	{
		if (IsInGameThread())
		{
			return Settings.IsValid() ? Settings->RenderTargetSize : 1.0f;
		}
		else
		{
			return Settings_RenderThread.IsValid() ? Settings_RenderThread->RenderTargetSize : 1.0f;
		}
	}

	void FOculusXRHMD::GetMotionControllerData(UObject* WorldContext, const EControllerHand Hand, FXRMotionControllerData& MotionControllerData)
	{
		MotionControllerData.DeviceName = OculusSystemName;
		MotionControllerData.ApplicationInstanceID = FApp::GetInstanceId();
		MotionControllerData.DeviceVisualType = EXRVisualType::Controller;
		MotionControllerData.TrackingStatus = ETrackingStatus::NotTracked;
		MotionControllerData.HandIndex = Hand;
		MotionControllerData.bValid = false;

		if ((Hand == EControllerHand::Left) || (Hand == EControllerHand::Right))
		{
			const FName MotionControllerName("OculusXRInputDevice");
			TArray<IMotionController*> MotionControllers = IModularFeatures::Get().GetModularFeatureImplementations<IMotionController>(IMotionController::GetModularFeatureName());
			const IMotionController* MotionController = nullptr;
			for (const IMotionController* Itr : MotionControllers)
			{
				if (Itr->GetMotionControllerDeviceTypeName() == MotionControllerName)
				{
					MotionController = Itr;
					break;
				}
			}

			const float WorldToMeters = GetWorldToMetersScale();
			if (MotionController)
			{
				bool bSuccess = false;
				FVector Position = FVector::ZeroVector;
				FRotator Rotation = FRotator::ZeroRotator;
				const FTransform TrackingToWorld = GetTrackingToWorldTransform();
				const FName AimSource = Hand == EControllerHand::Left ? FName("LeftAim") : FName("RightAim");
				bSuccess = MotionController->GetControllerOrientationAndPosition(0, AimSource, Rotation, Position, WorldToMeters);
				if (bSuccess)
				{
					MotionControllerData.AimPosition = TrackingToWorld.TransformPosition(Position);
					MotionControllerData.AimRotation = TrackingToWorld.TransformRotation(FQuat(Rotation));
				}
				MotionControllerData.bValid |= bSuccess;

				FName GripSource = Hand == EControllerHand::Left ? FName("LeftGrip") : FName("RightGrip");
				bSuccess = MotionController->GetControllerOrientationAndPosition(0, GripSource, Rotation, Position, WorldToMeters);
				if (bSuccess)
				{
					MotionControllerData.GripPosition = TrackingToWorld.TransformPosition(Position);
					MotionControllerData.GripRotation = TrackingToWorld.TransformRotation(FQuat(Rotation));
				}
				MotionControllerData.bValid |= bSuccess;

				MotionControllerData.TrackingStatus = MotionController->GetControllerTrackingStatus(0, GripSource);
			}
		}
	}

	bool FOculusXRHMD::IsStereoEnabled() const
	{
		if (IsInGameThread())
		{
			return Settings.IsValid() && Settings->IsStereoEnabled();
		}
		else
		{
			return Settings_RenderThread.IsValid() && Settings_RenderThread->IsStereoEnabled();
		}
	}

	bool FOculusXRHMD::IsStereoEnabledOnNextFrame() const
	{
		// !!!

		return Settings.IsValid() && Settings->IsStereoEnabled();
	}

	bool FOculusXRHMD::EnableStereo(bool bStereo)
	{
		CheckInGameThread();

		if (bStereo)
		{
			LoadFromSettings();
			CheckMultiPlayer();
		}

		return DoEnableStereo(bStereo);
	}

	void FOculusXRHMD::AdjustViewRect(int32 ViewIndex, int32& X, int32& Y, uint32& SizeX, uint32& SizeY) const
	{
		if (Settings.IsValid())
		{
			X = Settings->EyeUnscaledRenderViewport[ViewIndex].Min.X;
			Y = Settings->EyeUnscaledRenderViewport[ViewIndex].Min.Y;
			SizeX = Settings->EyeUnscaledRenderViewport[ViewIndex].Size().X;
			SizeY = Settings->EyeUnscaledRenderViewport[ViewIndex].Size().Y;
		}
		else
		{
			SizeX = SizeX / 2;
			X += SizeX * ViewIndex;
		}
	}

	FIntRect FOculusXRHMD::GetAsymmetricViewRect(const int32 ViewIndex, const FIntRect& ViewRect)
	{
		FIntRect AsymmetricViewRect = ViewRect;
		if (Settings_RenderThread.IsValid() && Frame_RenderThread.IsValid())
		{
			const ovrpFovf& EyeBufferFov = Frame_RenderThread->Fov[ViewIndex];
			const ovrpFovf& FrameFov = Frame_RenderThread->SymmetricFov[ViewIndex];
			const int32 ViewPixelSize = AsymmetricViewRect.Size().X;

			// if using symmetric rendering, only send UVs of the asymmetrical subrect (the rest isn't useful) to the VR runtime
			const float symTanSize = FrameFov.LeftTan + FrameFov.RightTan;

			AsymmetricViewRect.Min.X += (FrameFov.LeftTan - EyeBufferFov.LeftTan) * (ViewPixelSize / symTanSize);
			AsymmetricViewRect.Max.X -= (FrameFov.RightTan - EyeBufferFov.RightTan) * (ViewPixelSize / symTanSize);
		}

		return AsymmetricViewRect;
	}

	void FOculusXRHMD::SetFinalViewRect(FRHICommandListImmediate& RHICmdList, const int32 ViewIndex, const FIntRect& FinalViewRect)
	{
		CheckInRenderThread();
		if (ViewIndex == INDEX_NONE || ViewIndex < 0 || ViewIndex >= ovrpEye_Count)
		{
			return;
		}

		FIntRect AsymmetricViewRect = GetAsymmetricViewRect(ViewIndex, FinalViewRect);

		if (Settings_RenderThread.IsValid())
		{
			Settings_RenderThread->EyeRenderViewport[ViewIndex] = AsymmetricViewRect;
		}

		// Called after RHIThread has already started.  Need to update Settings_RHIThread as well.
		ExecuteOnRHIThread_DoNotWait([this, ViewIndex, AsymmetricViewRect]() {
			CheckInRHIThread();

			if (Settings_RHIThread.IsValid())
			{
				Settings_RHIThread->EyeRenderViewport[ViewIndex] = AsymmetricViewRect;
			}
		});
	}

#ifdef WITH_OCULUS_BRANCH
	void FOculusXRHMD::CalculateScissorRect(const int32 ViewIndex, const FIntRect& ViewRect, FIntRect& OutRect)
	{
		CheckInRenderThread();
		if (ViewIndex == INDEX_NONE || ViewIndex < 0 || ViewIndex >= ovrpEye_Count)
		{
			return;
		}

		OutRect = GetAsymmetricViewRect(ViewIndex, ViewRect);
	}
#endif // WITH_OCULUS_BRANCH

	void FOculusXRHMD::CalculateStereoViewOffset(const int32 ViewIndex, FRotator& ViewRotation, const float WorldToMeters, FVector& ViewLocation)
	{
		// This method is called from GetProjectionData on a game thread.
		if (InGameThread() && ViewIndex == EStereoscopicEye::eSSE_LEFT_EYE && NextFrameToRender.IsValid())
		{
			// Inverse out GameHeadPose.Rotation since PlayerOrientation already contains head rotation.
			FQuat HeadOrientation = FQuat::Identity;
			FVector HeadPosition;

			GetCurrentPose(HMDDeviceId, HeadOrientation, HeadPosition);

			NextFrameToRender->HeadOrientation = HeadOrientation;
			NextFrameToRender->PlayerOrientation = LastPlayerOrientation = ViewRotation.Quaternion() * HeadOrientation.Inverse();
			NextFrameToRender->PlayerLocation = LastPlayerLocation = ViewLocation;
		}

		FHeadMountedDisplayBase::CalculateStereoViewOffset(ViewIndex, ViewRotation, WorldToMeters, ViewLocation);
	}

	FMatrix FOculusXRHMD::GetStereoProjectionMatrix(int32 ViewIndex) const
	{
		CheckInGameThread();

		check(IsStereoEnabled());

		FMatrix proj = (ViewIndex == EStereoscopicEye::eSSE_MONOSCOPIC) ? ToFMatrix(Settings->MonoProjectionMatrix) : ToFMatrix(Settings->EyeProjectionMatrices[ViewIndex]);

		// correct far and near planes for reversed-Z projection matrix
		const float WorldScale = GetWorldToMetersScale() * (1.0 / 100.0f); // physical scale is 100 UUs/meter
		float InNearZ = GNearClippingPlane * WorldScale;

		proj.M[3][3] = 0.0f;
		proj.M[2][3] = 1.0f;

		proj.M[2][2] = 0.0f;
		proj.M[3][2] = InNearZ;

		return proj;
	}

	void FOculusXRHMD::InitCanvasFromView(FSceneView* InView, UCanvas* Canvas)
	{
		// This is used for placing small HUDs (with names)
		// over other players (for example, in Capture Flag).
		// HmdOrientation should be initialized by GetCurrentOrientation (or
		// user's own value).
	}

	void FOculusXRHMD::RenderTexture_RenderThread(class FRHICommandListImmediate& RHICmdList, class FRHITexture* BackBuffer, class FRHITexture* SrcTexture, FVector2D WindowSize) const
	{
		CheckInRenderThread();
		check(CustomPresent);

#if PLATFORM_ANDROID
		return;
#endif

		if (SpectatorScreenController)
		{
			SpectatorScreenController->RenderSpectatorScreen_RenderThread(RHICmdList, BackBuffer, SrcTexture, WindowSize);
		}
	}

	FVector2D FOculusXRHMD::GetEyeCenterPoint_RenderThread(int32 ViewIndex) const
	{
		CheckInRenderThread();

		check(IsStereoEnabled() || IsHeadTrackingEnforced());

		// Don't use GetStereoProjectionMatrix because it is game thread only on oculus, we also don't need the zplane adjustments for this.
		const FMatrix StereoProjectionMatrix = ToFMatrix(Settings_RenderThread->EyeProjectionMatrices[ViewIndex]);

		//0,0,1 is the straight ahead point, wherever it maps to is the center of the projection plane in -1..1 coordinates.  -1,-1 is bottom left.
		const FVector4 ScreenCenter = StereoProjectionMatrix.TransformPosition(FVector(0.0f, 0.0f, 1.0f));
		//transform into 0-1 screen coordinates 0,0 is top left.
		const FVector2D CenterPoint(0.5f + (ScreenCenter.X / 2.0f), 0.5f - (ScreenCenter.Y / 2.0f));

		return CenterPoint;
	}

	FIntRect FOculusXRHMD::GetFullFlatEyeRect_RenderThread(FTexture2DRHIRef EyeTexture) const
	{
		CheckInRenderThread();

		// Rift does this differently than other platforms, it already has an idea of what rectangle it wants to use stored.
		FIntRect& EyeRect = Settings_RenderThread->EyeRenderViewport[0];

		// But the rectangle rift specifies has corners cut off, so we will crop a little more.
		if (ShouldDisableHiddenAndVisibileAreaMeshForSpectatorScreen_RenderThread())
		{
			return EyeRect;
		}
		else
		{
			static FVector2D SrcNormRectMin(0.05f, 0.0f);
			static FVector2D SrcNormRectMax(0.95f, 1.0f);
			const int32 SizeX = EyeRect.Max.X - EyeRect.Min.X;
			const int32 SizeY = EyeRect.Max.Y - EyeRect.Min.Y;
			return FIntRect(EyeRect.Min.X + SizeX * SrcNormRectMin.X, EyeRect.Min.Y + SizeY * SrcNormRectMin.Y, EyeRect.Min.X + SizeX * SrcNormRectMax.X, EyeRect.Min.Y + SizeY * SrcNormRectMax.Y);
		}
	}

	void FOculusXRHMD::CopyTexture_RenderThread(FRHICommandListImmediate& RHICmdList, FRHITexture2D* SrcTexture, FIntRect SrcRect, FRHITexture2D* DstTexture, FIntRect DstRect, bool bClearBlack, bool bNoAlpha) const
	{
		if (bClearBlack)
		{
			FRHIRenderPassInfo RPInfo(DstTexture, ERenderTargetActions::DontLoad_Store);
			RHICmdList.BeginRenderPass(RPInfo, TEXT("ClearToBlack"));
			{
				const FIntRect ClearRect(0, 0, DstTexture->GetSizeX(), DstTexture->GetSizeY());
				RHICmdList.SetViewport(ClearRect.Min.X, ClearRect.Min.Y, 0, ClearRect.Max.X, ClearRect.Max.Y, 1.0f);
				DrawClearQuad(RHICmdList, FLinearColor::Black);
			}
			RHICmdList.EndRenderPass();
		}

		check(CustomPresent);
		CustomPresent->CopyTexture_RenderThread(RHICmdList, DstTexture, SrcTexture, DstRect, SrcRect, false, bNoAlpha, true, true);
	}

	bool FOculusXRHMD::PopulateAnalyticsAttributes(TArray<FAnalyticsEventAttribute>& EventAttributes)
	{
		if (!FHeadMountedDisplayBase::PopulateAnalyticsAttributes(EventAttributes))
		{
			return false;
		}

		EventAttributes.Add(FAnalyticsEventAttribute(TEXT("HQBuffer"), (bool)Settings->Flags.bHQBuffer));
		EventAttributes.Add(FAnalyticsEventAttribute(TEXT("HQDistortion"), (bool)Settings->Flags.bHQDistortion));
		EventAttributes.Add(FAnalyticsEventAttribute(TEXT("UpdateOnRT"), (bool)Settings->Flags.bUpdateOnRT));

		return true;
	}

	bool FOculusXRHMD::ShouldUseSeparateRenderTarget() const
	{
		return IsStereoEnabled();
	}

	void FOculusXRHMD::CalculateRenderTargetSize(const FViewport& Viewport, uint32& InOutSizeX, uint32& InOutSizeY)
	{
		// TODO this should use Settings_RenderThread if !CheckInGameThread()
		// This is called before StartRenderFrame_GameThread() on startup
		if (!Settings->IsStereoEnabled())
		{
			return;
		}

		InOutSizeX = Settings->RenderTargetSize.X;
		InOutSizeY = Settings->RenderTargetSize.Y;

		check(InOutSizeX != 0 && InOutSizeY != 0);
	}

	void FOculusXRHMD::AllocateEyeBuffer()
	{
		CheckInGameThread();

		ExecuteOnRenderThread([&]() {
			InitializeEyeLayer_RenderThread(GetImmediateCommandList_ForRenderCommand());

			const FXRSwapChainPtr& SwapChain = EyeLayer_RenderThread->GetSwapChain();
			if (SwapChain.IsValid())
			{
				const FRHITexture2D* const SwapChainTexture = SwapChain->GetTexture2DArray() ? SwapChain->GetTexture2DArray() : SwapChain->GetTexture2D();
				UE_LOG(LogHMD, Log, TEXT("Allocating Oculus %d x %d rendertarget swapchain"), SwapChainTexture->GetSizeX(), SwapChainTexture->GetSizeY());
			}
		});

		bNeedReAllocateViewportRenderTarget = true;
	}

	bool FOculusXRHMD::NeedReAllocateViewportRenderTarget(const FViewport& Viewport)
	{
		CheckInGameThread();

		return ensureMsgf(Settings.IsValid(), TEXT("Unexpected issue with Oculus settings on the GameThread. This should be valid when this is called in EnqueueBeginRenderFrame() - has the callsite changed?")) && Settings->IsStereoEnabled() && bNeedReAllocateViewportRenderTarget;
	}

	bool FOculusXRHMD::NeedReAllocateDepthTexture(const TRefCountPtr<IPooledRenderTarget>& DepthTarget)
	{
		CheckInRenderThread();

		return ensureMsgf(Settings_RenderThread.IsValid(), TEXT("Unexpected issue with Oculus settings on the RenderThread. This should be valid when this is called in AllocateCommonDepthTargets() - has the callsite changed?")) && Settings_RenderThread->IsStereoEnabled() && bNeedReAllocateDepthTexture_RenderThread;
	}

	bool FOculusXRHMD::NeedReAllocateShadingRateTexture(const TRefCountPtr<IPooledRenderTarget>& FoveationTarget)
	{
		CheckInRenderThread();

		return ensureMsgf(Settings_RenderThread.IsValid(), TEXT("Unexpected issue with Oculus settings on the RenderThread. This should be valid when this is called in AllocateFoveationTexture() - has the callsite changed?")) && Settings_RenderThread->IsStereoEnabled() && bNeedReAllocateFoveationTexture_RenderThread;
	}

#ifdef WITH_OCULUS_BRANCH
	bool FOculusXRHMD::NeedReAllocateMotionVectorTexture(const TRefCountPtr<IPooledRenderTarget>& MotionVectorTarget, const TRefCountPtr<IPooledRenderTarget>& MotionVectorDepthTarget)
	{
		CheckInRenderThread();

		return ensureMsgf(Settings_RenderThread.IsValid(), TEXT("Unexpected issue with Oculus settings on the RenderThread. This should be valid when this is called in AllocateMotionVectorTexture() - has the callsite changed?")) && Settings_RenderThread->IsStereoEnabled() && bNeedReAllocateMotionVectorTexture_RenderThread;
	}
#endif // WITH_OCULUS_BRANCH

	bool FOculusXRHMD::AllocateRenderTargetTexture(uint32 Index, uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, ETextureCreateFlags InTexFlags, ETextureCreateFlags InTargetableTextureFlags, FTexture2DRHIRef& OutTargetableTexture, FTexture2DRHIRef& OutShaderResourceTexture, uint32 NumSamples)
	{
		CheckInRenderThread();

		check(Index == 0);

		if (LayerMap[0].IsValid())
		{
			const FXRSwapChainPtr& SwapChain = EyeLayer_RenderThread->GetSwapChain();
			if (SwapChain.IsValid())
			{
				OutTargetableTexture = OutShaderResourceTexture = SwapChain->GetTexture2DArray() ? SwapChain->GetTexture2DArray() : SwapChain->GetTexture2D();
				bNeedReAllocateViewportRenderTarget = false;
				return true;
			}
		}

		OutTargetableTexture = OutShaderResourceTexture = nullptr;
		return false;
	}

	bool FOculusXRHMD::AllocateDepthTexture(uint32 Index, uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, ETextureCreateFlags FlagsIn, ETextureCreateFlags TargetableTextureFlags, FTexture2DRHIRef& OutTargetableTexture, FTexture2DRHIRef& OutShaderResourceTexture, uint32 NumSamples)
	{
		CheckInRenderThread();

		check(Index == 0);

		if (EyeLayer_RenderThread.IsValid())
		{
			const FXRSwapChainPtr& SwapChain = EyeLayer_RenderThread->GetDepthSwapChain();

			if (SwapChain.IsValid())
			{
				FTexture2DRHIRef Texture = SwapChain->GetTexture2DArray() ? SwapChain->GetTexture2DArray() : SwapChain->GetTexture2D();
				FIntPoint TexSize = Texture->GetSizeXY();

				// Ensure the texture size matches the eye layer. We may get other depth allocations unrelated to the main scene render.
				if (FIntPoint(SizeX, SizeY) == TexSize)
				{
					if (bNeedReAllocateDepthTexture_RenderThread)
					{
						UE_LOG(LogHMD, Log, TEXT("Allocating Oculus %d x %d depth rendertarget swapchain"), SizeX, SizeY);
						bNeedReAllocateDepthTexture_RenderThread = false;
					}

					OutTargetableTexture = OutShaderResourceTexture = Texture;
					return true;
				}
			}
		}

		OutTargetableTexture = OutShaderResourceTexture = nullptr;
		return false;
	}

	bool FOculusXRHMD::AllocateShadingRateTexture(uint32 Index, uint32 RenderSizeX, uint32 RenderSizeY, uint8 Format, uint32 NumMips, ETextureCreateFlags InTexFlags, ETextureCreateFlags InTargetableTextureFlags, FTexture2DRHIRef& OutTexture, FIntPoint& OutTextureSize)
	{
		CheckInRenderThread();

		check(Index == 0);

		if (EyeLayer_RenderThread.IsValid())
		{
			const FXRSwapChainPtr& SwapChain = EyeLayer_RenderThread->GetFoveationSwapChain();

			if (SwapChain.IsValid())
			{
				FTexture2DRHIRef Texture = SwapChain->GetTexture2DArray() ? SwapChain->GetTexture2DArray() : SwapChain->GetTexture2D();
				FIntPoint TexSize = Texture->GetSizeXY();

				// Only set texture and return true if we have a valid texture of compatible size
				if (Texture->IsValid() && TexSize.X > 0 && TexSize.Y > 0)
				{
					if (bNeedReAllocateFoveationTexture_RenderThread)
					{
						UE_LOG(LogHMD, Log, TEXT("Allocating Oculus %d x %d variable resolution swapchain"), TexSize.X, TexSize.Y, Index);
						bNeedReAllocateFoveationTexture_RenderThread = false;
					}

					// This is a hack to turn force the runtime to use FDM over FSR when we allocate our FDM to avoid a crash on Quest 3
					// TODO: Remove this for UE 5.3 after there's an engine-side fix
					ExecuteOnRHIThread_DoNotWait([this]() {
						// Set this in AllocateShadingRateTexture because it guarantees that this runs after VulkanExtensions has initially
						// selected the shading rate type, before the FDM is actually going to be used, and only when we actually have an FDM
						CustomPresent->UseFragmentDensityMapOverShadingRate_RHIThread();
					});

					OutTexture = Texture;
					OutTextureSize = TexSize;
					return true;
				}
			}
		}

		OutTexture = nullptr;
		return false;
	}

#ifdef WITH_OCULUS_BRANCH
	bool FOculusXRHMD::AllocateMotionVectorTexture(uint32 Index, uint8 Format, uint32 NumMips, ETextureCreateFlags InTexFlags, ETextureCreateFlags InTargetableTextureFlags, FTexture2DRHIRef& OutTexture, FIntPoint& OutTextureSize, FTexture2DRHIRef& OutDepthTexture, FIntPoint& OutDepthTextureSize)
	{
		CheckInRenderThread();

		check(Index == 0);
		if (EyeLayer_RenderThread.IsValid())
		{
			const FXRSwapChainPtr& SwapChain = EyeLayer_RenderThread->GetMotionVectorSwapChain();
			if (SwapChain.IsValid())
			{
				FTexture2DRHIRef Texture = SwapChain->GetTexture2DArray() ? SwapChain->GetTexture2DArray() : SwapChain->GetTexture2D();
				FIntPoint TexSize = Texture->GetSizeXY();

				const FXRSwapChainPtr& DepthSwapChain = EyeLayer_RenderThread->GetMotionVectorDepthSwapChain();
				if (DepthSwapChain.IsValid())
				{
					FTexture2DRHIRef DepthTexture = DepthSwapChain->GetTexture2DArray() ? DepthSwapChain->GetTexture2DArray() : DepthSwapChain->GetTexture2D();
					FIntPoint DepthTexSize = DepthTexture->GetSizeXY();

					if (DepthTexture->IsValid() && DepthTexSize.X > 0 && DepthTexSize.Y > 0)
					{
						OutDepthTextureSize = DepthTexSize;
						OutDepthTexture = DepthTexture;
					}
					else
					{
						return false;
					}
				}

				// Only set texture and return true if we have a valid texture of compatible size
				if (Texture->IsValid() && TexSize.X > 0 && TexSize.Y > 0)
				{
					if (bNeedReAllocateMotionVectorTexture_RenderThread)
					{
						UE_LOG(LogHMD, Log, TEXT("[Mobile SpaceWarp] Allocating Oculus %d x %d motion vector swapchain"), TexSize.X, TexSize.Y, Index);
						bNeedReAllocateMotionVectorTexture_RenderThread = false;
					}

					OutTexture = Texture;
					OutTextureSize = TexSize;
					return true;
				}
			}
		}

		OutTexture = nullptr;
		return false;
	}
#endif // WITH_OCULUS_BRANCH

#if defined(WITH_OCULUS_BRANCH)
	bool FOculusXRHMD::FindEnvironmentDepthTexture_RenderThread(FTextureRHIRef& OutTexture, FVector2f& OutDepthFactors, FMatrix44f OutScreenToDepthMatrices[2], FMatrix44f OutDepthViewProjMatrices[2])
	{
		CheckInRenderThread();

		if (Frame_RenderThread.IsValid())
		{
			int SwapchainIndex;
			if (ComputeEnvironmentDepthParameters_RenderThread(OutDepthFactors, OutScreenToDepthMatrices, OutDepthViewProjMatrices, SwapchainIndex))
			{
				if (SwapchainIndex >= EnvironmentDepthSwapchain.Num())
				{
					return false;
				}
				OutTexture = EnvironmentDepthSwapchain[SwapchainIndex];
				return true;
			}
		}
		return false;
	}
#endif // defined(WITH_OCULUS_BRANCH)

	EPixelFormat FOculusXRHMD::GetActualColorSwapchainFormat() const
	{
		if (!CustomPresent.IsValid())
		{
			UE_LOG(LogHMD, Log, TEXT("Invalid CustomPresent! PF_R8G8B8A8 will be used as the default swapchain format!"));
			return PF_R8G8B8A8;
		}
		return CustomPresent->GetDefaultPixelFormat();
	}

	void FOculusXRHMD::UpdateViewportWidget(bool bUseSeparateRenderTarget, const class FViewport& Viewport, class SViewport* ViewportWidget)
	{
		CheckInGameThread();
		check(ViewportWidget);

		TSharedPtr<SWindow> Window = CachedWindow.Pin();
		TSharedPtr<SWidget> CurrentlyCachedWidget = CachedViewportWidget.Pin();
		TSharedRef<SWidget> Widget = ViewportWidget->AsShared();

		if (!Window.IsValid() || Widget != CurrentlyCachedWidget)
		{
			Window = FSlateApplication::Get().FindWidgetWindow(Widget);

			CachedViewportWidget = Widget;
			CachedWindow = Window;
		}

		if (!Settings->IsStereoEnabled())
		{
			// Restore AutoResizeViewport mode for the window
			if (Window.IsValid())
			{
				Window->SetMirrorWindow(false);
				Window->SetViewportSizeDrivenByWindow(true);
			}
			return;
		}

		if (bUseSeparateRenderTarget && Frame.IsValid())
		{
			if (Window.IsValid())
			{
				const auto SlateWindowSize = Window->GetSizeInScreen();
				CachedWindowSize = FIntPoint(static_cast<int>(SlateWindowSize.X), static_cast<int>(SlateWindowSize.Y));
			}
			else
			{
				CachedWindowSize = Viewport.GetSizeXY();
			}
		}
	}

	FXRRenderBridge* FOculusXRHMD::GetActiveRenderBridge_GameThread(bool bUseSeparateRenderTarget)
	{
		CheckInGameThread();

		if (bUseSeparateRenderTarget && NextFrameToRender.IsValid())
		{
			return CustomPresent;
		}
		else
		{
			return nullptr;
		}
	}

	void FOculusXRHMD::UpdateHMDWornState()
	{
		const EHMDWornState::Type NewHMDWornState = GetHMDWornState();

		if (NewHMDWornState != HMDWornState)
		{
			HMDWornState = NewHMDWornState;
			if (HMDWornState == EHMDWornState::Worn)
			{
				FCoreDelegates::VRHeadsetPutOnHead.Broadcast();
			}
			else if (HMDWornState == EHMDWornState::NotWorn)
			{
				FCoreDelegates::VRHeadsetRemovedFromHead.Broadcast();
			}
		}
	}

	void FOculusXRHMD::UpdateHMDEvents()
	{
		ovrpEventDataBuffer buf;
		while (FOculusXRHMDModule::GetPluginWrapper().PollEvent(&buf) == ovrpSuccess)
		{
			if (buf.EventType == ovrpEventType_None)
			{
				break;
			}
			else if (buf.EventType == ovrpEventType_DisplayRefreshRateChange)
			{
				ovrpEventDisplayRefreshRateChange* rateChangedEvent = (ovrpEventDisplayRefreshRateChange*)&buf;
				FOculusEventDelegates::OculusDisplayRefreshRateChanged.Broadcast(rateChangedEvent->FromRefreshRate, rateChangedEvent->ToRefreshRate);
			}
			else
			{
				for (auto& it : EventPollingDelegates)
				{
					bool HandledEvent = false;
					it.ExecuteIfBound(&buf, HandledEvent);
				}
			}
		}
	}

	uint32 FOculusXRHMD::CreateLayer(const IStereoLayers::FLayerDesc& InLayerDesc)
	{
		CheckInGameThread();

		uint32 LayerId = NextLayerId++;
		FLayerPtr Layer = MakeShareable(new FLayer(LayerId));
		LayerMap.Add(LayerId, Layer);
		Layer->SetDesc(Settings.Get(), InLayerDesc);
		return LayerId;
	}

	void FOculusXRHMD::DestroyLayer(uint32 LayerId)
	{
		CheckInGameThread();
		FLayerPtr* LayerFound = LayerMap.Find(LayerId);
		if (LayerFound)
		{
			(*LayerFound)->DestroyLayer();
		}
		LayerMap.Remove(LayerId);
	}

	void FOculusXRHMD::SetLayerDesc(uint32 LayerId, const IStereoLayers::FLayerDesc& InLayerDesc)
	{
		CheckInGameThread();
		FLayerPtr* LayerFound = LayerMap.Find(LayerId);

		if (LayerFound)
		{
			FLayer* Layer = new FLayer(**LayerFound);
			Layer->SetDesc(Settings.Get(), InLayerDesc);
			*LayerFound = MakeShareable(Layer);
		}
	}

	bool FOculusXRHMD::GetLayerDesc(uint32 LayerId, IStereoLayers::FLayerDesc& OutLayerDesc)
	{
		CheckInGameThread();
		FLayerPtr* LayerFound = LayerMap.Find(LayerId);

		if (LayerFound)
		{
			OutLayerDesc = (*LayerFound)->GetDesc();
			return true;
		}

		return false;
	}

	void FOculusXRHMD::MarkTextureForUpdate(uint32 LayerId)
	{
		CheckInGameThread();
		FLayerPtr* LayerFound = LayerMap.Find(LayerId);

		if (LayerFound)
		{
			(*LayerFound)->MarkTextureForUpdate();
		}
	}

	void FOculusXRHMD::SetSplashRotationToForward()
	{
		//if update splash screen is shown, update the head orientation default to recenter splash screens
		FQuat HeadOrientation = FQuat::Identity;
		FVector HeadPosition;
		GetCurrentPose(HMDDeviceId, HeadOrientation, HeadPosition);
		SplashRotation = FRotator(HeadOrientation);
		SplashRotation.Pitch = 0;
		SplashRotation.Roll = 0;
	}

	FOculusXRSplashDesc FOculusXRHMD::GetUESplashScreenDesc()
	{
		FOculusXRSplashDesc Desc;
		Desc.LoadedTexture = bSplashShowMovie ? SplashMovie : SplashTexture;
		Desc.TransformInMeters = Desc.TransformInMeters * FTransform(SplashOffset / GetWorldToMetersScale());
		Desc.bNoAlphaChannel = true;
		Desc.bIsDynamic = bSplashShowMovie;
		Desc.QuadSizeInMeters *= SplashScale;
		return Desc;
	}

	void FOculusXRHMD::EyeTrackedFoveatedRenderingFallback()
	{
		FoveatedRenderingMethod = EOculusXRFoveatedRenderingMethod::FixedFoveatedRendering;
		FoveatedRenderingLevel = EOculusXRFoveatedRenderingLevel::High;
		bDynamicFoveatedRendering = true;
	}

	void FOculusXRHMD::GetAllocatedTexture(uint32 LayerId, FTextureRHIRef& Texture, FTextureRHIRef& LeftTexture)
	{
		Texture = LeftTexture = nullptr;
		FLayerPtr* LayerFound = nullptr;

		if (IsInGameThread())
		{
			LayerFound = LayerMap.Find(LayerId);
		}
		else if (IsInParallelRenderingThread())
		{
			for (int32 LayerIndex = 0; LayerIndex < Layers_RenderThread.Num(); LayerIndex++)
			{
				if (Layers_RenderThread[LayerIndex]->GetId() == LayerId)
				{
					LayerFound = &Layers_RenderThread[LayerIndex];
				}
			}
		}
		else if (IsInRHIThread())
		{
			for (int32 LayerIndex = 0; LayerIndex < Layers_RHIThread.Num(); LayerIndex++)
			{
				if (Layers_RHIThread[LayerIndex]->GetId() == LayerId)
				{
					LayerFound = &Layers_RHIThread[LayerIndex];
				}
			}
		}
		else
		{
			return;
		}

		if (LayerFound && (*LayerFound)->GetSwapChain().IsValid())
		{
			bool bRightTexture = (*LayerFound)->GetRightSwapChain().IsValid();
			const IStereoLayers::FLayerDesc& Desc = (*LayerFound)->GetDesc();

			if (Desc.HasShape<FCubemapLayer>())
			{
				if (bRightTexture)
				{
					Texture = (*LayerFound)->GetRightSwapChain()->GetTextureCube();
					LeftTexture = (*LayerFound)->GetSwapChain()->GetTextureCube();
				}
				else
				{
					Texture = LeftTexture = (*LayerFound)->GetSwapChain()->GetTextureCube();
				}
			}
			else if (Desc.HasShape<FCylinderLayer>() || Desc.HasShape<FQuadLayer>())
			{
				if (bRightTexture)
				{
					Texture = (*LayerFound)->GetRightSwapChain()->GetTexture2D();
					LeftTexture = (*LayerFound)->GetSwapChain()->GetTexture2D();
				}
				else
				{
					Texture = LeftTexture = (*LayerFound)->GetSwapChain()->GetTexture2D();
				}
			}
		}
	}

	IStereoLayers::FLayerDesc FOculusXRHMD::GetDebugCanvasLayerDesc(FTextureRHIRef Texture)
	{
		IStereoLayers::FLayerDesc StereoLayerDesc;

		ovrpBool cylinderSupported = ovrpBool_False;
		ovrpResult result = FOculusXRHMDModule::GetPluginWrapper().IsLayerShapeSupported(ovrpShape_Cylinder, &cylinderSupported);
		if (OVRP_SUCCESS(result) && cylinderSupported)
		{
			StereoLayerDesc = IStereoLayers::FLayerDesc(FCylinderLayer(100.f, 488.f / 4, 180.f));
			StereoLayerDesc.Transform = FTransform(FVector(0.f, 0, 0)); // 100/0/0 for quads
		}
		else
		{
			StereoLayerDesc.Transform = FTransform(FVector(100.f, 0, 0));
		}

		StereoLayerDesc.QuadSize = FVector2D(180.f, 180.f);
		StereoLayerDesc.PositionType = IStereoLayers::ELayerType::FaceLocked;
		StereoLayerDesc.LayerSize = Texture->GetTexture2D()->GetSizeXY();
		StereoLayerDesc.Flags = IStereoLayers::ELayerFlags::LAYER_FLAG_TEX_CONTINUOUS_UPDATE;
		StereoLayerDesc.Flags |= IStereoLayers::ELayerFlags::LAYER_FLAG_QUAD_PRESERVE_TEX_RATIO;
		return StereoLayerDesc;
	}

	void FOculusXRHMD::SetupViewFamily(FSceneViewFamily& InViewFamily)
	{
		InViewFamily.EngineShowFlags.StereoRendering = IsStereoEnabled();
	}

	void FOculusXRHMD::SetupView(FSceneViewFamily& InViewFamily, FSceneView& InView)
	{
		CheckInGameThread();
	}

	void FOculusXRHMD::BeginRenderViewFamily(FSceneViewFamily& InViewFamily)
	{
		CheckInGameThread();

		if (Settings.IsValid() && Settings->IsStereoEnabled())
		{
			// This should already have been set by UpdateStereoRenderingParams().
			// It must still match the value used there.
			check(Settings->CurrentShaderPlatform == InViewFamily.Scene->GetShaderPlatform());
			Settings->Flags.bsRGBEyeBuffer = IsMobilePlatform(Settings->CurrentShaderPlatform) && IsMobileColorsRGB();

			if (NextFrameToRender.IsValid())
			{
				NextFrameToRender->ShowFlags = InViewFamily.EngineShowFlags;
			}

			if (SpectatorScreenController != nullptr)
			{
				SpectatorScreenController->BeginRenderViewFamily();
			}
		}

		StartRenderFrame_GameThread();
	}

	void FOculusXRHMD::EnableInsightPassthrough_RenderThread(bool bEnablePassthrough)
	{
		const bool bShouldEnable = (InsightInitStatus == FInsightInitStatus::NotInitialized) && bEnablePassthrough;

		if (bShouldEnable)
		{
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().InitializeInsightPassthrough()))
			{
				UE_LOG(LogHMD, Log, TEXT("Passthrough Initialized"));
				InsightInitStatus = FInsightInitStatus::Initialized;
			}
			else
			{
				InsightInitStatus = FInsightInitStatus::Failed;
				UE_LOG(LogHMD, Log, TEXT("Passthrough initialization failed"));
			}
		}
		else
		{
			const bool bShouldShutdown = (InsightInitStatus == FInsightInitStatus::Initialized) && !bEnablePassthrough;
			if (bShouldShutdown)
			{
				// it may already be deinitialized.
				if (!FOculusXRHMDModule::GetPluginWrapper().GetInsightPassthroughInitialized() || OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().ShutdownInsightPassthrough()))
				{
					UE_LOG(LogHMD, Log, TEXT("Passthrough shutdown"));
					InsightInitStatus = FInsightInitStatus::NotInitialized;
				}
				else
				{
					UE_LOG(LogHMD, Log, TEXT("Failed to shut down passthrough. It may be still in use."));
				}
			}
		}
	}

	void FOculusXRHMD::PreRenderViewFamily_RenderThread(FRDGBuilder& GraphBuilder, FSceneViewFamily& ViewFamily)
	{
		CheckInRenderThread();
	}

	void FOculusXRHMD::OnBeginRendering_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneViewFamily& ViewFamily)
	{
		CheckInRenderThread();

		if (!Frame_RenderThread.IsValid())
		{
			return;
		}

		if (!Settings_RenderThread.IsValid() || !Settings_RenderThread->IsStereoEnabled())
		{
			return;
		}

		// If using OVRPlugin OpenXR, only update spectator screen mode with VR focus, since we are running the frameloop
		// and cycling through the swapchain even without VR focus with OVRPlugin OpenXR
		ovrpXrApi NativeXrApi;
		FOculusXRHMDModule::GetPluginWrapper().GetNativeXrApiType(&NativeXrApi);
		if (SpectatorScreenController && (NativeXrApi != ovrpXrApi_OpenXR || FApp::HasVRFocus()))
		{
			SpectatorScreenController->UpdateSpectatorScreenMode_RenderThread();
			Frame_RenderThread->Flags.bSpectatorScreenActive = SpectatorScreenController->GetSpectatorScreenMode() != ESpectatorScreenMode::Disabled;
		}

		// Update mirror texture
		CustomPresent->UpdateMirrorTexture_RenderThread();

#if !PLATFORM_ANDROID
#if 0 // The entire target should be cleared by the tonemapper and pp material \
	  // Clear the padding between two eyes
		const int32 GapMinX = ViewFamily.Views[0]->UnscaledViewRect.Max.X;
		const int32 GapMaxX = ViewFamily.Views[1]->UnscaledViewRect.Min.X;

		if (GapMinX < GapMaxX)
		{
			SCOPED_DRAW_EVENT(RHICmdList, OculusClearQuad)

			const int32 GapMinY = ViewFamily.Views[0]->UnscaledViewRect.Min.Y;
			const int32 GapMaxY = ViewFamily.Views[1]->UnscaledViewRect.Max.Y;

			FRHIRenderPassInfo RPInfo(ViewFamily.RenderTarget->GetRenderTargetTexture(), ERenderTargetActions::DontLoad_Store);
			RHICmdList.BeginRenderPass(RPInfo, TEXT("Clear"));
			{
				RHICmdList.SetViewport(GapMinX, GapMinY, 0, GapMaxX, GapMaxY, 1.0f);
				DrawClearQuad(RHICmdList, FLinearColor::Black);
			}
			RHICmdList.EndRenderPass();
		}
#endif
#else
		// ensure we have attached JNI to this thread - this has to happen persistently as the JNI could detach if the app loses focus
		FAndroidApplication::GetJavaEnv();
#endif

		EnableInsightPassthrough_RenderThread(Settings_RenderThread->Flags.bInsightPassthroughEnabled);

		// Start RHI frame
		StartRHIFrame_RenderThread();

		// Update performance stats
		PerformanceStats.Frames++;
		PerformanceStats.Seconds = FPlatformTime::Seconds();
	}

	void FOculusXRHMD::PreRenderView_RenderThread(FRDGBuilder& GraphBuilder, FSceneView& InView)
	{
	}

	void FOculusXRHMD::PostRenderViewFamily_RenderThread(FRDGBuilder& GraphBuilder, FSceneViewFamily& InViewFamily)
	{
		CheckInRenderThread();

		if (InViewFamily.Views[0]->StereoPass != EStereoscopicPass::eSSP_FULL)
		{
			FinishRenderFrame_RenderThread(GraphBuilder);
		}
	}

#if UE_VERSION_OLDER_THAN(5, 3, 0)
	void FOculusXRHMD::PostRenderBasePassMobile_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneView& InView)
#else
	void FOculusXRHMD::PostRenderBasePassMobile_RenderThread(FRHICommandList& RHICmdList, FSceneView& InView)
#endif
	{
		if (bHardOcclusionsEnabled)
		{
			RenderHardOcclusions_RenderThread(RHICmdList, InView);
		}
#ifndef WITH_OCULUS_BRANCH
		UpdateFoveationOffsets_RenderThread();
#endif
	}

	BEGIN_SHADER_PARAMETER_STRUCT(FPostBasePassViewExtensionParameters, )
	SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FSceneTextureUniformParameters, SceneTextures)
	RENDER_TARGET_BINDING_SLOTS()
	END_SHADER_PARAMETER_STRUCT()

	void FOculusXRHMD::PostRenderBasePassDeferred_RenderThread(FRDGBuilder& GraphBuilder, FSceneView& InView, const FRenderTargetBindingSlots& RenderTargets, TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTextures)
	{
		if (bHardOcclusionsEnabled)
		{
			auto* PassParameters = GraphBuilder.AllocParameters<FPostBasePassViewExtensionParameters>();
			PassParameters->RenderTargets = RenderTargets;
			PassParameters->SceneTextures = SceneTextures;

			GraphBuilder.AddPass(RDG_EVENT_NAME("RenderHardOcclusions_RenderThread"), PassParameters, ERDGPassFlags::Raster, [this, &InView](FRHICommandListImmediate& RHICmdList) {
				RenderHardOcclusions_RenderThread(RHICmdList, InView);
			});
		}
	}

#ifdef WITH_OCULUS_BRANCH
#if UE_VERSION_OLDER_THAN(5, 3, 0)
	void FOculusXRHMD::PostSceneColorRenderingMobile_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneView& InView)
#else
	void FOculusXRHMD::PostSceneColorRenderingMobile_RenderThread(FRHICommandList& RHICmdList, FSceneView& InView)
#endif
	{
		UpdateFoveationOffsets_RenderThread();
	}
#endif

	int32 FOculusXRHMD::GetPriority() const
	{
		// We want to run after the FDefaultXRCamera's view extension
		return -1;
	}

#ifdef WITH_OCULUS_BRANCH
	bool FOculusXRHMD::LateLatchingEnabled() const
	{
#if OCULUS_HMD_SUPPORTED_PLATFORMS_VULKAN && PLATFORM_ANDROID
		// No LateLatching supported when occlusion culling is enabled due to mid frame submission
		// No LateLatching supported for non Multi view ATM due to viewUniformBuffer reusing.
		// The setting can be disabled in FOculusXRHMD::UpdateStereoRenderingParams
		return Settings->bLateLatching;
#else
		return false;
#endif
	}

	void FOculusXRHMD::PreLateLatchingViewFamily_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneViewFamily& InViewFamily)
	{
		CheckInRenderThread();
		FGameFrame* CurrentFrame = GetFrame_RenderThread();
		if (CurrentFrame)
		{
			CurrentFrame->Flags.bRTLateUpdateDone = false; // Allow LateLatching to update poses again
		}
	}
#endif

	bool FOculusXRHMD::SupportsSpaceWarp() const
	{
#if PLATFORM_ANDROID
		// Use All static value here since those can't be change at runtime
		ensureMsgf(CustomPresent.IsValid(), TEXT("SupportsSpaceWarp can only be called post CustomPresent created"));
		const bool bOvrPlugin_OpenXR = Settings->XrApi == EOculusXRXrApi::OVRPluginOpenXR;
		static const auto CVarMobileMultiView = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("vr.MobileMultiView"));
		static const auto CVarSupportMobileSpaceWarp = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("vr.SupportMobileSpaceWarp"));
		bool bIsMobileMultiViewEnabled = (CVarMobileMultiView && CVarMobileMultiView->GetValueOnAnyThread() != 0);
		bool bIsUsingMobileMultiView = GSupportsMobileMultiView && bIsMobileMultiViewEnabled;
		bool bIsVulkan = CustomPresent->GetRenderAPI() == ovrpRenderAPI_Vulkan;
		bool spaceWarpSupported = bOvrPlugin_OpenXR && bIsVulkan && bIsUsingMobileMultiView && CVarSupportMobileSpaceWarp && (CVarSupportMobileSpaceWarp->GetValueOnAnyThread() != 0);
		return spaceWarpSupported;
#else
		return false;
#endif
	}

	FOculusXRHMD::FOculusXRHMD(const FAutoRegister& AutoRegister)
		: FHeadMountedDisplayBase(nullptr)
		, FHMDSceneViewExtension(AutoRegister)
		, ConsoleCommands(this)
		, InsightInitStatus(FInsightInitStatus::NotInitialized)
		, bShutdownRequestQueued(false)
		, bShouldWait_GameThread(true)
		, bIsRendering_RenderThread(false)
	{
		Flags.Raw = 0;
		OCFlags.Raw = 0;
		TrackingOrigin = EHMDTrackingOrigin::Type::Eye;
		DeltaControlRotation = FRotator::ZeroRotator; // used from ApplyHmdRotation
		LastPlayerOrientation = FQuat::Identity;
		LastPlayerLocation = FVector::ZeroVector;
		CachedWindowSize = FIntPoint::ZeroValue;
		CachedWorldToMetersScale = 100.0f;
		LastTrackingToWorld = FTransform::Identity;

		NextFrameNumber = 0;
		WaitFrameNumber = (uint32)-1;
		NextLayerId = 0;

		Settings = CreateNewSettings();

		RendererModule = nullptr;

		SplashLayerHandle = -1;

		SplashRotation = FRotator();

		bIsStandaloneStereoOnlyDevice = IHeadMountedDisplayModule::IsAvailable() && IHeadMountedDisplayModule::Get().IsStandaloneStereoOnlyDevice();

		bMultiPlayer = false;
	}

	FOculusXRHMD::~FOculusXRHMD()
	{
		Shutdown();
	}

	bool FOculusXRHMD::Startup()
	{
		if (GIsEditor)
		{
			Settings->Flags.bHeadTrackingEnforced = true;
		}

		check(!CustomPresent.IsValid());

		FString RHIString;
		{
			FString HardwareDetails = FHardwareInfo::GetHardwareDetailsString();
			FString RHILookup = NAME_RHI.ToString() + TEXT("=");

			if (!FParse::Value(*HardwareDetails, *RHILookup, RHIString))
			{
				return false;
			}
		}

#if OCULUS_HMD_SUPPORTED_PLATFORMS_D3D11
		if (RHIString == TEXT("D3D11"))
		{
			CustomPresent = CreateCustomPresent_D3D11(this);
		}
		else
#endif
#if OCULUS_HMD_SUPPORTED_PLATFORMS_D3D12
			if (RHIString == TEXT("D3D12"))
		{
			CustomPresent = CreateCustomPresent_D3D12(this);
		}
		else
#endif
#if OCULUS_HMD_SUPPORTED_PLATFORMS_VULKAN
			if (RHIString == TEXT("Vulkan"))
		{
			CustomPresent = CreateCustomPresent_Vulkan(this);
		}
		else
#endif
		{
			UE_LOG(LogHMD, Warning, TEXT("%s is not currently supported by OculusXRHMD plugin"), *RHIString);
			return false;
		}

		// grab a pointer to the renderer module for displaying our mirror window
		static const FName RendererModuleName("Renderer");
		RendererModule = FModuleManager::GetModulePtr<IRendererModule>(RendererModuleName);

#if PLATFORM_ANDROID
		// register our application lifetime delegates
		FCoreDelegates::ApplicationWillEnterBackgroundDelegate.AddRaw(this, &FOculusXRHMD::ApplicationPauseDelegate);
		FCoreDelegates::ApplicationHasEnteredForegroundDelegate.AddRaw(this, &FOculusXRHMD::ApplicationResumeDelegate);
#endif

		// Create eye layer
		IStereoLayers::FLayerDesc EyeLayerDesc;
		EyeLayerDesc.Priority = INT_MIN;
		EyeLayerDesc.Flags = LAYER_FLAG_TEX_CONTINUOUS_UPDATE;
		uint32 EyeLayerId = CreateLayer(EyeLayerDesc);
		check(EyeLayerId == 0);

		Splash = MakeShareable(new FSplash(this));
		Splash->Startup();

#if !PLATFORM_ANDROID
		SpectatorScreenController = MakeUnique<FSpectatorScreenController>(this);
#endif
		UE_LOG(LogHMD, Log, TEXT("Oculus plugin initialized. Version: %s"), *GetVersionString());

		return true;
	}

	void FOculusXRHMD::PreShutdown()
	{
		if (Splash.IsValid())
		{
			Splash->PreShutdown();
		}
	}

	void FOculusXRHMD::Shutdown()
	{
		CheckInGameThread();

		if (Splash.IsValid())
		{
			Splash->Shutdown();
			Splash = nullptr;
			// The base implementation stores a raw pointer to the Splash object and tries to deallocate it in its destructor
			LoadingScreen = nullptr;
		}

		if (CustomPresent.IsValid())
		{
			CustomPresent->Shutdown();
			CustomPresent = nullptr;
		}

		ReleaseDevice();

		Settings.Reset();
		LayerMap.Reset();
	}

	void FOculusXRHMD::ApplicationPauseDelegate()
	{
		ExecuteOnRenderThread([this]() {
			ExecuteOnRHIThread([this]() {
				FOculusXRHMDModule::GetPluginWrapper().DestroyDistortionWindow2();
			});
		});
		OCFlags.AppIsPaused = true;
	}

	void FOculusXRHMD::ApplicationResumeDelegate()
	{
		if (OCFlags.AppIsPaused && !InitializeSession())
		{
			UE_LOG(LogHMD, Log, TEXT("HMD initialization failed"));
		}
		OCFlags.AppIsPaused = false;
	}

	static const FString EYE_TRACKING_PERMISSION_NAME("com.oculus.permission.EYE_TRACKING");

	bool FOculusXRHMD::CheckEyeTrackingPermission(EOculusXRFoveatedRenderingMethod InFoveatedRenderingMethod)
	{
#if PLATFORM_ANDROID
		// Check and request eye tracking permissions, bind delegate for handling permission request result
		if (!UAndroidPermissionFunctionLibrary::CheckPermission(EYE_TRACKING_PERMISSION_NAME))
		{
			TArray<FString> Permissions;
			Permissions.Add(EYE_TRACKING_PERMISSION_NAME);
			UAndroidPermissionCallbackProxy* Proxy = UAndroidPermissionFunctionLibrary::AcquirePermissions(Permissions);
			Proxy->OnPermissionsGrantedDelegate.AddLambda([this, InFoveatedRenderingMethod](const TArray<FString>& Permissions, const TArray<bool>& GrantResults) {
				int PermIndex = Permissions.Find(EYE_TRACKING_PERMISSION_NAME);
				if (PermIndex != INDEX_NONE && GrantResults[PermIndex])
				{
					UE_LOG(LogHMD, Verbose, TEXT("com.oculus.permission.EYE_TRACKING permission granted"));
					FoveatedRenderingMethod = InFoveatedRenderingMethod;
					FOculusEventDelegates::OculusEyeTrackingStateChanged.Broadcast(true);
				}
				else
				{
					UE_LOG(LogHMD, Log, TEXT("com.oculus.permission.EYE_TRACKING permission denied"));
					if (InFoveatedRenderingMethod == EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering)
					{
						EyeTrackedFoveatedRenderingFallback();
					}
					FOculusEventDelegates::OculusEyeTrackingStateChanged.Broadcast(false);
				}
			});
			return false;
		}
#endif // PLATFORM_ANDROID
		return true;
	}

	bool FOculusXRHMD::InitializeSession()
	{
		UE_LOG(LogHMD, Log, TEXT("Initializing OVRPlugin session"));

		if (!FOculusXRHMDModule::GetPluginWrapper().GetInitialized())
		{
#if !UE_BUILD_SHIPPING
			ovrpLogCallback logCallback = OvrpLogCallback;
#else
			ovrpLogCallback logCallback = nullptr;
#endif

#if PLATFORM_ANDROID
			void* activity = (void*)FAndroidApplication::GetGameActivityThis();
#else
			void* activity = nullptr;
#endif

			int initializeFlags = GIsEditor ? ovrpInitializeFlag_SupportsVRToggle : 0;

			initializeFlags |= CustomPresent->SupportsSRGB() ? ovrpInitializeFlag_SupportSRGBFrameBuffer : 0;

			if (Settings->Flags.bSupportsDash)
			{
				initializeFlags |= ovrpInitializeFlag_FocusAware;
			}

			if (SupportsSpaceWarp()) // Configure for space warp
			{
				initializeFlags |= ovrpInitializeFlag_SupportAppSpaceWarp;
				UE_LOG(LogHMD, Log, TEXT("[Mobile SpaceWarp] Application is configured to support mobile spacewarp"));
			}
			bNeedReAllocateMotionVectorTexture_RenderThread = false;

#if WITH_EDITOR && PLATFORM_WINDOWS
			// Attempt Late Initialization in-editor
			// FOculusXRHMDModule::PreInit always returns true in this case,
			// so we need to check the flag directly.
			if (GIsEditor && FOculusXRHMDModule::Get().PreInit() && !FOculusXRHMDModule::Get().bPreInit)
			{
				return false;
			}
#endif

			if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().Initialize7(
					CustomPresent->GetRenderAPI(),
					logCallback,
					activity,
					CustomPresent->GetOvrpInstance(),
					CustomPresent->GetOvrpPhysicalDevice(),
					CustomPresent->GetOvrpDevice(),
					CustomPresent->GetOvrpCommandQueue(),
					nullptr /*vkGetInstanceProcAddr*/,
					0 /*vkQueueFamilyIndex*/,
					nullptr /*d3dDevice*/,
					initializeFlags,
					{ OVRP_VERSION })))
			{
				return false;
			}

			ovrpBool Supported = ovrpBool_False;
			if (Settings->bSupportEyeTrackedFoveatedRendering)
			{
				FOculusXRHMDModule::GetPluginWrapper().GetFoveationEyeTrackedSupported(&Supported);
			}
			bEyeTrackedFoveatedRenderingSupported = Supported == ovrpBool_True;
			SetFoveatedRenderingMethod(Settings->FoveatedRenderingMethod);
			SetFoveatedRenderingLevel(Settings->FoveatedRenderingLevel, Settings->bDynamicFoveatedRendering);

			NextFrameNumber = 0;
			WaitFrameNumber = (uint32)-1;
		}

		FOculusXRHMDModule::GetPluginWrapper().SetAppEngineInfo2(
			"Unreal Engine",
			TCHAR_TO_ANSI(*FEngineVersion::Current().ToString()),
			GIsEditor ? ovrpBool_True : ovrpBool_False);

		int flag = ovrpDistortionWindowFlag_None;

		FOculusXRHMDModule::GetPluginWrapper().SetupDistortionWindow3(flag);
		FOculusXRHMDModule::GetPluginWrapper().SetSuggestedCpuPerformanceLevel((ovrpProcessorPerformanceLevel)Settings->SuggestedCpuPerfLevel);
		FOculusXRHMDModule::GetPluginWrapper().SetSuggestedGpuPerformanceLevel((ovrpProcessorPerformanceLevel)Settings->SuggestedGpuPerfLevel);
		FOculusXRHMDModule::GetPluginWrapper().SetFoveationEyeTracked(FoveatedRenderingMethod == EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering);
		FOculusXRHMDModule::GetPluginWrapper().SetTiledMultiResLevel((ovrpTiledMultiResLevel)FoveatedRenderingLevel.load());
		FOculusXRHMDModule::GetPluginWrapper().SetTiledMultiResDynamic(bDynamicFoveatedRendering.load());
		FOculusXRHMDModule::GetPluginWrapper().SetAppCPUPriority2(ovrpBool_True);
		FOculusXRHMDModule::GetPluginWrapper().SetLocalDimming(ovrpBool_True);

		OCFlags.NeedSetTrackingOrigin = true;

		FOculusXRHMDModule::GetPluginWrapper().SetClientColorDesc((ovrpColorSpace)Settings->ColorSpace);

		return true;
	}

	void FOculusXRHMD::ShutdownSession()
	{
		ExecuteOnRenderThread([this]() {
			ExecuteOnRHIThread([this]() {
				FOculusXRHMDModule::GetPluginWrapper().DestroyDistortionWindow2();
			});
		});

		FOculusXRHMDModule::GetPluginWrapper().Shutdown2();

		bIsRendering_RenderThread = false;
	}

	bool FOculusXRHMD::InitDevice()
	{
		CheckInGameThread();

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized())
		{
			// Already created and present
			return true;
		}

		if (!IsHMDEnabled())
		{
			// Don't bother if HMD is not connected
			return false;
		}

		LoadFromSettings();

		if (!InitializeSession())
		{
			UE_LOG(LogHMD, Log, TEXT("HMD initialization failed"));
			return false;
		}

		// Don't need to reset these flags on application resume, so put them in InitDevice instead of InitializeSession
		bNeedReAllocateViewportRenderTarget = true;
		bNeedReAllocateDepthTexture_RenderThread = false;
		bNeedReAllocateFoveationTexture_RenderThread = false;
		Flags.bNeedDisableStereo = false;
		OCFlags.NeedSetFocusToGameViewport = true;

		if (!CustomPresent->IsUsingCorrectDisplayAdapter())
		{
			UE_LOG(LogHMD, Error, TEXT("Using incorrect display adapter for HMD."));
			ShutdownSession();
			return false;
		}

		if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetSystemHeadsetType2(&Settings->SystemHeadset)))
		{
			Settings->SystemHeadset = ovrpSystemHeadset_None;
		}

		FOculusXRHMDModule::GetPluginWrapper().Update3(ovrpStep_Render, 0, 0.0);

		if (Settings->Flags.bPixelDensityAdaptive)
		{
			static const auto DynamicResOperationCVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.DynamicRes.OperationMode"));
			if (DynamicResOperationCVar)
			{
				DynamicResOperationCVar->Set(2);
			}
			GEngine->ChangeDynamicResolutionStateAtNextFrame(MakeShareable(new FDynamicResolutionState(Settings)));
		}

		UpdateHmdRenderInfo();
		UpdateStereoRenderingParams();

		const bool bEnablePassthrough = Settings->Flags.bInsightPassthroughEnabled;

		ExecuteOnRenderThread([this, bEnablePassthrough](FRHICommandListImmediate& RHICmdList) {
			InitializeEyeLayer_RenderThread(RHICmdList);
			EnableInsightPassthrough_RenderThread(bEnablePassthrough);
		});

		if (!EyeLayer_RenderThread.IsValid() || !EyeLayer_RenderThread->GetSwapChain().IsValid())
		{
			UE_LOG(LogHMD, Error, TEXT("Failed to create eye layer swap chain."));
			ShutdownSession();
			return false;
		}

		if (!HiddenAreaMeshes[0].IsValid() || !HiddenAreaMeshes[1].IsValid())
		{
			SetupOcclusionMeshes();
		}

#if !UE_BUILD_SHIPPING
		DrawDebugDelegateHandle = UDebugDrawService::Register(TEXT("Game"), FDebugDrawDelegate::CreateRaw(this, &FOculusXRHMD::DrawDebug));
#endif

		// Do not set VR focus in Editor by just creating a device; Editor may have it created w/o requiring focus.
		// Instead, set VR focus in OnBeginPlay (VR Preview will run there first).
		if (!GIsEditor)
		{
			FApp::SetUseVRFocus(true);
			FApp::SetHasVRFocus(true);
		}

		FOculusXRHMDModule::GetPluginWrapper().SetClientColorDesc((ovrpColorSpace)Settings->ColorSpace);

		return true;
	}

	void FOculusXRHMD::ReleaseDevice()
	{
		CheckInGameThread();

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized())
		{
			// Wait until the next frame before ending the session (workaround for DX12/Vulkan resources being ripped out from under us before we're done with them).
			bShutdownRequestQueued = true;
		}
	}

	void BuildOcclusionMesh(FRHICommandList& RHICmdList, FHMDViewMesh& Mesh, ovrpEye Eye, ovrpViewportStencilType MeshType)
	{
		int VertexCount = 0;
		int IndexCount = 0;

		ovrpResult Result = ovrpResult::ovrpFailure;
		if (OVRP_FAILURE(Result = FOculusXRHMDModule::GetPluginWrapper().GetViewportStencil(Eye, MeshType, nullptr, &VertexCount, nullptr, &IndexCount)))
		{
			return;
		}

		FRHIResourceCreateInfo CreateInfo(TEXT("FOculusXRHMD"));
#if UE_VERSION_OLDER_THAN(5, 3, 0)
		Mesh.VertexBufferRHI = RHICreateVertexBuffer(sizeof(FFilterVertex) * VertexCount, BUF_Static, CreateInfo);
		void* VoidPtr = RHILockBuffer(Mesh.VertexBufferRHI, 0, sizeof(FFilterVertex) * VertexCount, RLM_WriteOnly);
#else
		Mesh.VertexBufferRHI = RHICmdList.CreateVertexBuffer(sizeof(FFilterVertex) * VertexCount, BUF_Static, CreateInfo);
		void* VoidPtr = RHICmdList.LockBuffer(Mesh.VertexBufferRHI, 0, sizeof(FFilterVertex) * VertexCount, RLM_WriteOnly);
#endif
		FFilterVertex* pVertices = reinterpret_cast<FFilterVertex*>(VoidPtr);

#if UE_VERSION_OLDER_THAN(5, 3, 0)
		Mesh.IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint16), sizeof(uint16) * IndexCount, BUF_Static, CreateInfo);
		void* VoidPtr2 = RHILockBuffer(Mesh.IndexBufferRHI, 0, sizeof(uint16) * IndexCount, RLM_WriteOnly);
#else
		Mesh.IndexBufferRHI = RHICmdList.CreateIndexBuffer(sizeof(uint16), sizeof(uint16) * IndexCount, BUF_Static, CreateInfo);
		void* VoidPtr2 = RHICmdList.LockBuffer(Mesh.IndexBufferRHI, 0, sizeof(uint16) * IndexCount, RLM_WriteOnly);
#endif
		uint16* pIndices = reinterpret_cast<uint16*>(VoidPtr2);

		ovrpVector2f* const ovrpVertices = new ovrpVector2f[VertexCount];

		FOculusXRHMDModule::GetPluginWrapper().GetViewportStencil(Eye, MeshType, ovrpVertices, &VertexCount, pIndices, &IndexCount);

		for (int i = 0; i < VertexCount; ++i)
		{
			FFilterVertex& Vertex = pVertices[i];
			CA_SUPPRESS(6385); //  warning C6385: Reading invalid data from 'ovrpVertices':  the readable size is 'VertexCount*8' bytes, but '16' bytes may be read
			const ovrpVector2f& Position = ovrpVertices[i];
			if (MeshType == ovrpViewportStencilType_HiddenArea)
			{
				Vertex.Position.X = (Position.x * 2.0f) - 1.0f;
				Vertex.Position.Y = (Position.y * 2.0f) - 1.0f;
				Vertex.Position.Z = 1.0f;
				Vertex.Position.W = 1.0f;
				Vertex.UV.X = 0.0f;
				Vertex.UV.Y = 0.0f;
			}
			else if (MeshType == ovrpViewportStencilType_VisibleArea)
			{
				Vertex.Position.X = Position.x;
				Vertex.Position.Y = 1.0f - Position.y;
				Vertex.Position.Z = 0.0f;
				Vertex.Position.W = 1.0f;
				Vertex.UV.X = Position.x;
				Vertex.UV.Y = 1.0f - Position.y;
			}
			else
			{
				check(0);
			}
		}

		Mesh.NumIndices = IndexCount;
		Mesh.NumVertices = VertexCount;
		Mesh.NumTriangles = IndexCount / 3;

		delete[] ovrpVertices;

#if UE_VERSION_OLDER_THAN(5, 3, 0)
		RHIUnlockBuffer(Mesh.VertexBufferRHI);
		RHIUnlockBuffer(Mesh.IndexBufferRHI);
#else
		RHICmdList.UnlockBuffer(Mesh.VertexBufferRHI);
		RHICmdList.UnlockBuffer(Mesh.IndexBufferRHI);
#endif
	}

	void FOculusXRHMD::SetupOcclusionMeshes()
	{
		CheckInGameThread();

		FOculusXRHMD* const Self = this;
		ENQUEUE_RENDER_COMMAND(SetupOcclusionMeshesCmd)
		([Self](FRHICommandList& RHICmdList) {
			BuildOcclusionMesh(RHICmdList, Self->HiddenAreaMeshes[0], ovrpEye_Left, ovrpViewportStencilType_HiddenArea);
			BuildOcclusionMesh(RHICmdList, Self->HiddenAreaMeshes[1], ovrpEye_Right, ovrpViewportStencilType_HiddenArea);
			BuildOcclusionMesh(RHICmdList, Self->VisibleAreaMeshes[0], ovrpEye_Left, ovrpViewportStencilType_VisibleArea);
			BuildOcclusionMesh(RHICmdList, Self->VisibleAreaMeshes[1], ovrpEye_Right, ovrpViewportStencilType_VisibleArea);
		});
	}

	static ovrpMatrix4f ovrpMatrix4f_Projection(const ovrpFrustum2f& frustum, bool leftHanded)
	{
		float handednessScale = leftHanded ? 1.0f : -1.0f;

		// A projection matrix is very like a scaling from NDC, so we can start with that.
		float projXScale = 2.0f / (frustum.Fov.LeftTan + frustum.Fov.RightTan);
		float projXOffset = (frustum.Fov.LeftTan - frustum.Fov.RightTan) * projXScale * 0.5f;
		float projYScale = 2.0f / (frustum.Fov.UpTan + frustum.Fov.DownTan);
		float projYOffset = (frustum.Fov.UpTan - frustum.Fov.DownTan) * projYScale * 0.5f;

		ovrpMatrix4f projection;

		// Produces X result, mapping clip edges to [-w,+w]
		projection.M[0][0] = projXScale;
		projection.M[0][1] = 0.0f;
		projection.M[0][2] = handednessScale * projXOffset;
		projection.M[0][3] = 0.0f;

		// Produces Y result, mapping clip edges to [-w,+w]
		// Hey - why is that YOffset negated?
		// It's because a projection matrix transforms from world coords with Y=up,
		// whereas this is derived from an NDC scaling, which is Y=down.
		projection.M[1][0] = 0.0f;
		projection.M[1][1] = projYScale;
		projection.M[1][2] = handednessScale * -projYOffset;
		projection.M[1][3] = 0.0f;

		// Produces Z-buffer result
		projection.M[2][0] = 0.0f;
		projection.M[2][1] = 0.0f;
		if (FGenericPlatformMath::IsFinite(frustum.zFar))
		{
			projection.M[2][2] = -handednessScale * frustum.zFar / (frustum.zNear - frustum.zFar);
			projection.M[2][3] = (frustum.zFar * frustum.zNear) / (frustum.zNear - frustum.zFar);
		}
		else
		{
			projection.M[2][2] = handednessScale;
			projection.M[2][3] = -frustum.zNear;
		}

		// Produces W result (= Z in)
		projection.M[3][0] = 0.0f;
		projection.M[3][1] = 0.0f;
		projection.M[3][2] = handednessScale;
		projection.M[3][3] = 0.0f;

		return projection;
	}

	void FOculusXRHMD::UpdateStereoRenderingParams()
	{
		CheckInGameThread();

		// Update PixelDensity
		bool bSupportsDepth = true;

		if (Settings->Flags.bPixelDensityAdaptive)
		{
			FLayer* EyeLayer = EyeLayer_RenderThread.Get();
			float NewPixelDensity = 1.0;
			if (EyeLayer && EyeLayer->GetOvrpId())
			{
				ovrpSizei RecommendedResolution = { 0, 0 };
				FOculusXRHMDModule::GetPluginWrapper().GetLayerRecommendedResolution(EyeLayer->GetOvrpId(), &RecommendedResolution);
				if (RecommendedResolution.h > 0)
				{
					NewPixelDensity = RecommendedResolution.h * (float)Settings->PixelDensityMax / Settings->RenderTargetSize.Y;
				}
			}

			const float PixelDensityCVarOverride = CVarOculusDynamicResolutionPixelDensity.GetValueOnAnyThread();
			if (PixelDensityCVarOverride > 0)
			{
				NewPixelDensity = PixelDensityCVarOverride;
			}
			Settings->SetPixelDensitySmooth(NewPixelDensity);
		}
		else
		{
			static const auto PixelDensityCVar = IConsoleManager::Get().FindConsoleVariable(TEXT("vr.PixelDensity"));
			Settings->SetPixelDensity(PixelDensityCVar ? PixelDensityCVar->GetFloat() : 1.0f);

			// Due to hijacking the depth target directly from the scene context, we can't support depth compositing if it's being scaled by screen percentage since it wont match our color render target dimensions.
			static const auto ScreenPercentageCVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.ScreenPercentage"));
			float ScreenPercentage = (!ScreenPercentageCVar) ? 100.0f : ScreenPercentageCVar->GetFloat();
#if !UE_VERSION_OLDER_THAN(5, 3, 0)
			// 5.3 changes the default screen percentage to 0 and uses r.ScreenPercentage.Default values to determine screen percentage
			if (ScreenPercentageCVar->GetFloat() <= 0.0f)
			{
				static const auto VRScreenPercentageModeCVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.ScreenPercentage.Default.VR.Mode"));
				// With default VR screen percentage modes, only support depth with manual screen percentage set to 100
				if (VRScreenPercentageModeCVar && VRScreenPercentageModeCVar->GetInt() == static_cast<int>(EScreenPercentageMode::Manual))
				{
					static const auto ManualScreenPercentageCVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.ScreenPercentage.Default"));
					ScreenPercentage = ManualScreenPercentageCVar->GetFloat();
				}
			}
#endif
			bSupportsDepth = ScreenPercentage == 100.0f;
		}

		// Update EyeLayer
		FLayerPtr* EyeLayerFound = LayerMap.Find(0);
		FLayer* EyeLayer = new FLayer(**EyeLayerFound);
		*EyeLayerFound = MakeShareable(EyeLayer);

		ovrpLayout Layout = ovrpLayout_DoubleWide;

		static const auto CVarMobileMultiView = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("vr.MobileMultiView"));
		const bool bIsMobileMultiViewEnabled = (CVarMobileMultiView && CVarMobileMultiView->GetValueOnAnyThread() != 0);

		const bool bIsUsingMobileMultiView = (GSupportsMobileMultiView || GRHISupportsArrayIndexFromAnyShader) && bIsMobileMultiViewEnabled;

		Settings->CurrentFeatureLevel = GEngine ? GEngine->GetDefaultWorldFeatureLevel() : GMaxRHIFeatureLevel;
		Settings->CurrentShaderPlatform = GShaderPlatformForFeatureLevel[Settings->CurrentFeatureLevel];

		// for now only mobile rendering codepaths use the array rendering system, so PC-native should stay in doublewide
		if (bIsUsingMobileMultiView && IsMobilePlatform(Settings->CurrentShaderPlatform))
		{
			Layout = ovrpLayout_Array;
		}

#if PLATFORM_ANDROID
		if (!bIsUsingMobileMultiView && Settings->bLateLatching)
		{
			UE_CLOG(true, LogHMD, Error, TEXT("LateLatching can't be used when Multiview is off, force disabling."));
			Settings->bLateLatching = false;
		}

		if (GetMutableDefault<URendererSettings>()->bOcclusionCulling && Settings->bLateLatching)
		{
			UE_CLOG(true, LogHMD, Error, TEXT("LateLatching can't used when Occlusion culling is on due to mid frame vkQueueSubmit, force disabling"));
			Settings->bLateLatching = false;
		}
#endif

		const bool bForceSymmetric = CVarOculusForceSymmetric.GetValueOnAnyThread() == 1 && (Layout == ovrpLayout_Array);

		ovrpLayerDesc_EyeFov EyeLayerDesc;
		const bool requestsSubsampled = CVarOculusEnableSubsampledLayout.GetValueOnAnyThread() == 1 && CustomPresent->SupportsSubsampled();
		int eyeLayerFlags = requestsSubsampled ? ovrpLayerFlag_Subsampled : 0;

		ovrpTextureFormat MvPixelFormat = ovrpTextureFormat_R16G16B16A16_FP;
		ovrpTextureFormat MvDepthFormat = ovrpTextureFormat_D24_S8;
		int SpaceWarpAllocateFlag = 0;

		if (SupportsSpaceWarp())
		{
			SpaceWarpAllocateFlag = ovrpLayerFlag_SpaceWarpDataAllocation | ovrpLayerFlag_SpaceWarpDedicatedDepth;

			bool spaceWarpEnabledByUser = CVarOculusEnableSpaceWarpUser.GetValueOnAnyThread() != 0;
			bool spaceWarpEnabledInternal = CVarOculusEnableSpaceWarpInternal.GetValueOnAnyThread() != 0;
			if (spaceWarpEnabledByUser != spaceWarpEnabledInternal)
			{
				CVarOculusEnableSpaceWarpInternal->Set(spaceWarpEnabledByUser);
			}
		}

		const bool bCompositeDepth = Settings->Flags.bCompositeDepth;

		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().CalculateEyeLayerDesc3(
				Layout,
				Settings->Flags.bPixelDensityAdaptive ? Settings->PixelDensityMax : Settings->PixelDensity,
				Settings->Flags.bHQDistortion ? 0 : 1,
				1, // UNDONE
				CustomPresent->GetOvrpTextureFormat(CustomPresent->GetDefaultPixelFormat(), Settings->Flags.bsRGBEyeBuffer),
				(bCompositeDepth && bSupportsDepth) ? CustomPresent->GetDefaultDepthOvrpTextureFormat() : ovrpTextureFormat_None,
				MvPixelFormat,
				MvDepthFormat,
				1.0f,
				CustomPresent->GetLayerFlags() | eyeLayerFlags | SpaceWarpAllocateFlag,
				&EyeLayerDesc)))
		{
			ovrpFovf FrameFov[ovrpEye_Count] = { EyeLayerDesc.Fov[0], EyeLayerDesc.Fov[1] };
			if (bForceSymmetric)
			{
				// calculate symmetric FOV from runtime-provided asym in EyeLayerDesc
				FrameFov[0].RightTan = FrameFov[1].RightTan = FMath::Max(EyeLayerDesc.Fov[0].RightTan, EyeLayerDesc.Fov[1].RightTan);
				FrameFov[0].LeftTan = FrameFov[1].LeftTan = FMath::Max(EyeLayerDesc.Fov[0].LeftTan, EyeLayerDesc.Fov[1].LeftTan);

				const float asymTanSize = EyeLayerDesc.Fov[0].RightTan + EyeLayerDesc.Fov[0].LeftTan;
				const float symTanSize = FrameFov[0].RightTan + FrameFov[0].LeftTan;

				// compute new resolution from a number of tile multiple, and the increase in width from symmetric FOV
				const int numberTiles = (int)floor(EyeLayerDesc.TextureSize.w * symTanSize / (96.0 * asymTanSize));
				EyeLayerDesc.TextureSize.w = EyeLayerDesc.MaxViewportSize.w = numberTiles * 96;
			}

			// Scaling for DynamicResolution will happen later - see FSceneRenderer::PrepareViewRectsForRendering.
			// If scaling does occur, EyeRenderViewport will be updated in FOculusXRHMD::SetFinalViewRect.
			FIntPoint UnscaledViewportSize = FIntPoint(EyeLayerDesc.MaxViewportSize.w, EyeLayerDesc.MaxViewportSize.h);
			if (Settings->Flags.bPixelDensityAdaptive)
			{
				FIntPoint ViewRect = FIntPoint(
					FMath::CeilToInt(EyeLayerDesc.MaxViewportSize.w / Settings->PixelDensityMax),
					FMath::CeilToInt(EyeLayerDesc.MaxViewportSize.h / Settings->PixelDensityMax));
				UnscaledViewportSize = ViewRect;

				FIntPoint UpperViewRect = FIntPoint(
					FMath::CeilToInt(ViewRect.X * Settings->PixelDensityMax),
					FMath::CeilToInt(ViewRect.Y * Settings->PixelDensityMax));

				FIntPoint TextureSize;
				QuantizeSceneBufferSize(UpperViewRect, TextureSize);

				EyeLayerDesc.MaxViewportSize.w = TextureSize.X;
				EyeLayerDesc.MaxViewportSize.h = TextureSize.Y;
			}

			// Unreal assumes no gutter between eyes
			EyeLayerDesc.TextureSize.w = EyeLayerDesc.MaxViewportSize.w;
			EyeLayerDesc.TextureSize.h = EyeLayerDesc.MaxViewportSize.h;

			if (Layout == ovrpLayout_DoubleWide)
			{
				EyeLayerDesc.TextureSize.w *= 2;
			}

			EyeLayer->SetEyeLayerDesc(EyeLayerDesc);
			EyeLayer->bNeedsTexSrgbCreate = Settings->Flags.bsRGBEyeBuffer;

			Settings->RenderTargetSize = FIntPoint(EyeLayerDesc.TextureSize.w, EyeLayerDesc.TextureSize.h);
			Settings->EyeRenderViewport[0].Min = FIntPoint::ZeroValue;
			Settings->EyeRenderViewport[0].Max = UnscaledViewportSize;
			Settings->EyeRenderViewport[1].Min = FIntPoint(Layout == ovrpLayout_DoubleWide ? UnscaledViewportSize.X : 0, 0);
			Settings->EyeRenderViewport[1].Max = Settings->EyeRenderViewport[1].Min + UnscaledViewportSize;

			Settings->EyeUnscaledRenderViewport[0] = Settings->EyeRenderViewport[0];
			Settings->EyeUnscaledRenderViewport[1] = Settings->EyeRenderViewport[1];

			// Update projection matrices
			ovrpFrustum2f frustumLeft = { 0.001f, 1000.0f, FrameFov[0] };
			ovrpFrustum2f frustumRight = { 0.001f, 1000.0f, FrameFov[1] };
			ovrpFrustum2f frustumCenter = { 0.001f, 1000.0f, { FrameFov[0].UpTan, FrameFov[0].DownTan, FrameFov[0].LeftTan, FrameFov[1].RightTan } };

			Settings->EyeProjectionMatrices[0] = ovrpMatrix4f_Projection(frustumLeft, true);
			Settings->EyeProjectionMatrices[1] = ovrpMatrix4f_Projection(frustumRight, true);
			Settings->MonoProjectionMatrix = ovrpMatrix4f_Projection(frustumCenter, true);

			// given that we send a subrect in vpRectSubmit, the FOV is the default asym one in EyeLayerDesc, not FrameFov
			if (Frame.IsValid())
			{
				Frame->Fov[0] = EyeLayerDesc.Fov[0];
				Frame->Fov[1] = EyeLayerDesc.Fov[1];
				Frame->SymmetricFov[0] = FrameFov[0];
				Frame->SymmetricFov[1] = FrameFov[1];
			}

			// Flag if need to recreate render targets
			if (!EyeLayer->CanReuseResources(EyeLayer_RenderThread.Get()))
			{
				AllocateEyeBuffer();
			}
		}
	}

	void FOculusXRHMD::UpdateHmdRenderInfo()
	{
		CheckInGameThread();
		FOculusXRHMDModule::GetPluginWrapper().GetSystemDisplayFrequency2(&Settings->VsyncToNextVsync);
	}

	void FOculusXRHMD::InitializeEyeLayer_RenderThread(FRHICommandListImmediate& RHICmdList)
	{
		check(!InGameThread());
		CheckInRenderThread();

		if (LayerMap[0].IsValid())
		{
			FLayerPtr EyeLayer = LayerMap[0]->Clone();
			EyeLayer->Initialize_RenderThread(Settings_RenderThread.Get(), CustomPresent, &DeferredDeletion, RHICmdList, EyeLayer_RenderThread.Get());

			if (Layers_RenderThread.Num() > 0)
			{
				Layers_RenderThread[0] = EyeLayer;
			}
			else
			{
				Layers_RenderThread.Add(EyeLayer);
			}

			if (EyeLayer->GetDepthSwapChain().IsValid())
			{
				if (!EyeLayer_RenderThread.IsValid() || EyeLayer->GetDepthSwapChain() != EyeLayer_RenderThread->GetDepthSwapChain())
				{
					bNeedReAllocateDepthTexture_RenderThread = true;
				}
			}
			if (EyeLayer->GetFoveationSwapChain().IsValid())
			{
				if (!EyeLayer_RenderThread.IsValid() || EyeLayer->GetFoveationSwapChain() != EyeLayer_RenderThread->GetFoveationSwapChain())
				{
					bNeedReAllocateFoveationTexture_RenderThread = true;
				}
#if !UE_VERSION_OLDER_THAN(5, 3, 0)
				FoveationImageGenerator = MakeShared<FOculusXRFoveatedRenderingImageGenerator, ESPMode::ThreadSafe>(EyeLayer->GetFoveationSwapChain());
#endif // !UE_VERSION_OLDER_THAN(5, 3, 0)
			}

			if (EyeLayer->GetMotionVectorSwapChain().IsValid())
			{
				if (!EyeLayer_RenderThread.IsValid() || EyeLayer->GetMotionVectorSwapChain() != EyeLayer_RenderThread->GetMotionVectorSwapChain()
					|| EyeLayer->GetMotionVectorDepthSwapChain() != EyeLayer_RenderThread->GetMotionVectorDepthSwapChain())
				{
					bNeedReAllocateMotionVectorTexture_RenderThread = true;
					UE_LOG(LogHMD, VeryVerbose, TEXT("[Mobile SpaceWarp]  request to re-allocate motionVector textures"));
				}
			}

			if (EyeLayer_RenderThread.IsValid())
			{
				DeferredDeletion.AddLayerToDeferredDeletionQueue(EyeLayer_RenderThread);
			}

			EyeLayer_RenderThread = EyeLayer;
		}
	}

	void FOculusXRHMD::ApplySystemOverridesOnStereo(bool force)
	{
		CheckInGameThread();
		// ALWAYS SET r.FinishCurrentFrame to 0! Otherwise the perf might be poor.
		// @TODO: revise the FD3D11DynamicRHI::RHIEndDrawingViewport code (and other renderers)
		// to ignore this var completely.
		static const auto CFinishFrameVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.FinishCurrentFrame"));
		CFinishFrameVar->Set(0);
	}

	bool FOculusXRHMD::OnOculusStateChange(bool bIsEnabledNow)
	{
		if (!bIsEnabledNow)
		{
			// Switching from stereo
			ReleaseDevice();

			ResetControlRotation();
			return true;
		}
		else
		{
			// Switching to stereo
			if (InitDevice())
			{
				Flags.bApplySystemOverridesOnStereo = true;
				return true;
			}
			DeltaControlRotation = FRotator::ZeroRotator;
		}
		return false;
	}

	class FSceneViewport* FOculusXRHMD::FindSceneViewport()
	{
		if (!GIsEditor)
		{
			UGameEngine* GameEngine = Cast<UGameEngine>(GEngine);
			return GameEngine->SceneViewport.Get();
		}
#if WITH_EDITOR
		else
		{
			UEditorEngine* EditorEngine = CastChecked<UEditorEngine>(GEngine);
			FSceneViewport* PIEViewport = (FSceneViewport*)EditorEngine->GetPIEViewport();
			if (PIEViewport != nullptr && PIEViewport->IsStereoRenderingAllowed())
			{
				// PIE is setup for stereo rendering
				return PIEViewport;
			}
			else
			{
				// Check to see if the active editor viewport is drawing in stereo mode
				// @todo vreditor: Should work with even non-active viewport!
				FSceneViewport* EditorViewport = (FSceneViewport*)EditorEngine->GetActiveViewport();
				if (EditorViewport != nullptr && EditorViewport->IsStereoRenderingAllowed())
				{
					return EditorViewport;
				}
			}
		}
#endif
		return nullptr;
	}

	bool FOculusXRHMD::ShouldDisableHiddenAndVisibileAreaMeshForSpectatorScreen_RenderThread() const
	{
		CheckInRenderThread();

		// If you really need the eye corners to look nice, and can't just crop more,
		// and are willing to suffer a frametime hit... you could do this:
#if 0
		switch(GetSpectatorScreenMode_RenderThread())
		{
		case ESpectatorScreenMode::SingleEyeLetterboxed:
		case ESpectatorScreenMode::SingleEyeCroppedToFill:
		case ESpectatorScreenMode::TexturePlusEye:
			return true;
		}
#endif

		return false;
	}

	ESpectatorScreenMode FOculusXRHMD::GetSpectatorScreenMode_RenderThread() const
	{
		CheckInRenderThread();
		return SpectatorScreenController ? SpectatorScreenController->GetSpectatorScreenMode() : ESpectatorScreenMode::Disabled;
	}

#if !UE_BUILD_SHIPPING
	static const char* FormatLatencyReading(char* buff, size_t size, float val)
	{
		if (val < 0.000001f)
		{
			FCStringAnsi::Strcpy(buff, size, "N/A   ");
		}
		else
		{
			FCStringAnsi::Snprintf(buff, size, "%4.2fms", val * 1000.0f);
		}
		return buff;
	}

	void FOculusXRHMD::DrawDebug(UCanvas* InCanvas, APlayerController* InPlayerController)
	{
		CheckInGameThread();

		if (InCanvas && IsStereoEnabled() && Settings->Flags.bShowStats)
		{
			static const FColor TextColor(0, 255, 0);
			// Pick a larger font on console.
			UFont* const Font = FPlatformProperties::SupportsWindowedMode() ? GEngine->GetSmallFont() : GEngine->GetMediumFont();
			const int32 RowHeight = FMath::TruncToInt(Font->GetMaxCharHeight() * 1.1f);

			float ClipX = InCanvas->ClipX;
			float ClipY = InCanvas->ClipY;
			float LeftPos = 0;

			ClipX -= 100;
			LeftPos = ClipX * 0.3f;
			float TopPos = ClipY * 0.4f;

			int32 X = (int32)LeftPos;
			int32 Y = (int32)TopPos;

			FString Str;

			if (!Settings->Flags.bPixelDensityAdaptive)
			{
				Str = FString::Printf(TEXT("PD: %.2f"), Settings->PixelDensity);
			}
			else
			{
				Str = FString::Printf(TEXT("PD: %.2f [%0.2f, %0.2f]"), Settings->PixelDensity,
					Settings->PixelDensityMin, Settings->PixelDensityMax);
			}
			InCanvas->Canvas->DrawShadowedString(X, Y, *Str, Font, TextColor);
			Y += RowHeight;

			Str = FString::Printf(TEXT("W-to-m scale: %.2f uu/m"), GetWorldToMetersScale());
			InCanvas->Canvas->DrawShadowedString(X, Y, *Str, Font, TextColor);

			ovrpAppLatencyTimings AppLatencyTimings;
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetAppLatencyTimings2(&AppLatencyTimings)))
			{
				Y += RowHeight;

				char buf[5][20];
				char destStr[100];

				FCStringAnsi::Snprintf(destStr, sizeof(destStr), "Latency, ren: %s tw: %s pp: %s err: %s %s",
					FormatLatencyReading(buf[0], sizeof(buf[0]), AppLatencyTimings.LatencyRender),
					FormatLatencyReading(buf[1], sizeof(buf[1]), AppLatencyTimings.LatencyTimewarp),
					FormatLatencyReading(buf[2], sizeof(buf[2]), AppLatencyTimings.LatencyPostPresent),
					FormatLatencyReading(buf[3], sizeof(buf[3]), AppLatencyTimings.ErrorRender),
					FormatLatencyReading(buf[4], sizeof(buf[4]), AppLatencyTimings.ErrorTimewarp));

				Str = ANSI_TO_TCHAR(destStr);
				InCanvas->Canvas->DrawShadowedString(X, Y, *Str, Font, TextColor);
			}

			// Second row
			X = (int32)LeftPos + 200;
			Y = (int32)TopPos;

			Str = FString::Printf(TEXT("HQ dist: %s"), (Settings->Flags.bHQDistortion) ? TEXT("ON") : TEXT("OFF"));
			InCanvas->Canvas->DrawShadowedString(X, Y, *Str, Font, TextColor);
			Y += RowHeight;

			float UserIPD;
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetUserIPD2(&UserIPD)))
			{
				Str = FString::Printf(TEXT("IPD: %.2f mm"), UserIPD * 1000.f);
				InCanvas->Canvas->DrawShadowedString(X, Y, *Str, Font, TextColor);
				Y += RowHeight;
			}
		}
	}
#endif // #if !UE_BUILD_SHIPPING

	FOculusXRHMD* FOculusXRHMD::GetOculusXRHMD()
	{
#if OCULUS_HMD_SUPPORTED_PLATFORMS
		if (GEngine && GEngine->XRSystem.IsValid())
		{
			if (GEngine->XRSystem->GetSystemName() == OculusXRHMD::FOculusXRHMD::OculusSystemName)
			{
				return static_cast<OculusXRHMD::FOculusXRHMD*>(GEngine->XRSystem.Get());
			}
		}
#endif
		return nullptr;
	}

	bool FOculusXRHMD::IsHMDActive() const
	{
		return FOculusXRHMDModule::GetPluginWrapper().GetInitialized() != ovrpBool_False;
	}

	float FOculusXRHMD::GetWorldToMetersScale() const
	{
		CheckInGameThread();

		if (NextFrameToRender.IsValid())
		{
			return NextFrameToRender->WorldToMetersScale;
		}

		if (GWorld != nullptr)
		{
#if WITH_EDITOR
			// Workaround to allow WorldToMeters scaling to work correctly for controllers while running inside PIE.
			// The main world will most likely not be pointing at the PIE world while polling input, so if we find a world context
			// of that type, use that world's WorldToMeters instead.
			if (GIsEditor)
			{
				for (const FWorldContext& Context : GEngine->GetWorldContexts())
				{
					if (Context.WorldType == EWorldType::PIE)
					{
						return Context.World()->GetWorldSettings()->WorldToMeters;
					}
				}
			}
#endif //WITH_EDITOR

			// We're not currently rendering a frame, so just use whatever world to meters the main world is using.
			// This can happen when we're polling input in the main engine loop, before ticking any worlds.
			return GWorld->GetWorldSettings()->WorldToMeters;
		}

		return 100.0f;
	}

	FVector FOculusXRHMD::GetNeckPosition(const FQuat& HeadOrientation, const FVector& HeadPosition)
	{
		CheckInGameThread();

		FVector NeckPosition = HeadOrientation.Inverse().RotateVector(HeadPosition);

		ovrpVector2f NeckEyeDistance;
		if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetUserNeckEyeDistance2(&NeckEyeDistance)))
		{
			const float WorldToMetersScale = GetWorldToMetersScale();
			NeckPosition.X -= NeckEyeDistance.x * WorldToMetersScale;
			NeckPosition.Z -= NeckEyeDistance.y * WorldToMetersScale;
		}

		return NeckPosition;
	}

	void FOculusXRHMD::SetBaseOffsetInMeters(const FVector& BaseOffset)
	{
		CheckInGameThread();

		Settings->BaseOffset = BaseOffset;
	}

	FVector FOculusXRHMD::GetBaseOffsetInMeters() const
	{
		CheckInGameThread();

		return Settings->BaseOffset;
	}

	bool FOculusXRHMD::ConvertPose(const ovrpPosef& InPose, FPose& OutPose) const
	{
		CheckInGameThread();

		if (!NextFrameToRender.IsValid())
		{
			return false;
		}

		return ConvertPose_Internal(InPose, OutPose, Settings.Get(), NextFrameToRender->WorldToMetersScale);
	}

	bool FOculusXRHMD::ConvertPose(const FPose& InPose, ovrpPosef& OutPose) const
	{
		CheckInGameThread();

		if (!NextFrameToRender.IsValid())
		{
			return false;
		}

		return ConvertPose_Internal(InPose, OutPose, Settings.Get(), NextFrameToRender->WorldToMetersScale);
	}

	bool FOculusXRHMD::ConvertPose_RenderThread(const ovrpPosef& InPose, FPose& OutPose) const
	{
		CheckInRenderThread();

		if (!Frame_RenderThread.IsValid())
		{
			return false;
		}

		return ConvertPose_Internal(InPose, OutPose, Settings_RenderThread.Get(), Frame_RenderThread->WorldToMetersScale);
	}

	bool FOculusXRHMD::ConvertPose_Internal(const ovrpPosef& InPose, FPose& OutPose, const FSettings* Settings, float WorldToMetersScale)
	{
		return OculusXRHMD::ConvertPose_Internal(InPose, OutPose, Settings->BaseOrientation, Settings->BaseOffset, WorldToMetersScale);
	}

	bool FOculusXRHMD::ConvertPose_Internal(const FPose& InPose, ovrpPosef& OutPose, const FSettings* Settings, float WorldToMetersScale)
	{
		return OculusXRHMD::ConvertPose_Internal(InPose, OutPose, Settings->BaseOrientation, Settings->BaseOffset, WorldToMetersScale);
	}

	FVector FOculusXRHMD::ScaleAndMovePointWithPlayer(ovrpVector3f& OculusXRHMDPoint)
	{
		CheckInGameThread();

		FMatrix TranslationMatrix;
		TranslationMatrix.SetIdentity();
		TranslationMatrix = TranslationMatrix.ConcatTranslation(LastPlayerLocation);

		FVector ConvertedPoint = ToFVector(OculusXRHMDPoint) * GetWorldToMetersScale();
		FRotator RotateWithPlayer = LastPlayerOrientation.Rotator();
		FVector TransformWithPlayer = RotateWithPlayer.RotateVector(ConvertedPoint);
		TransformWithPlayer = FVector(TranslationMatrix.TransformPosition(TransformWithPlayer));

		if (GetXRCamera(HMDDeviceId)->GetUseImplicitHMDPosition())
		{
			FQuat HeadOrientation = FQuat::Identity;
			FVector HeadPosition;
			GetCurrentPose(HMDDeviceId, HeadOrientation, HeadPosition);
			TransformWithPlayer -= RotateWithPlayer.RotateVector(HeadPosition);
		}

		return TransformWithPlayer;
	}

	ovrpVector3f FOculusXRHMD::WorldLocationToOculusPoint(const FVector& InUnrealPosition)
	{
		CheckInGameThread();
		FQuat AdjustedPlayerOrientation = GetBaseOrientation().Inverse() * LastPlayerOrientation;
		AdjustedPlayerOrientation.Normalize();

		FVector AdjustedPlayerLocation = LastPlayerLocation;
		if (GetXRCamera(HMDDeviceId)->GetUseImplicitHMDPosition())
		{
			FQuat HeadOrientation = FQuat::Identity; // Unused
			FVector HeadPosition;
			GetCurrentPose(HMDDeviceId, HeadOrientation, HeadPosition);
			AdjustedPlayerLocation -= LastPlayerOrientation.Inverse().RotateVector(HeadPosition);
		}
		const FTransform InvWorldTransform = FTransform(AdjustedPlayerOrientation, AdjustedPlayerLocation).Inverse();
		const FVector ConvertedPosition = InvWorldTransform.TransformPosition(InUnrealPosition) / GetWorldToMetersScale();

		return ToOvrpVector3f(ConvertedPosition);
	}

	float FOculusXRHMD::ConvertFloat_M2U(float OculusFloat) const
	{
		CheckInGameThread();

		return OculusFloat * GetWorldToMetersScale();
	}

	FVector FOculusXRHMD::ConvertVector_M2U(ovrpVector3f OculusXRHMDPoint) const
	{
		CheckInGameThread();

		return ToFVector(OculusXRHMDPoint) * GetWorldToMetersScale();
	}

	bool FOculusXRHMD::GetUserProfile(UserProfile& OutProfile)
	{
		float UserIPD;
		ovrpVector2f UserNeckEyeDistance;
		float UserEyeHeight;

		if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized() && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetUserIPD2(&UserIPD)) && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetUserNeckEyeDistance2(&UserNeckEyeDistance)) && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetUserEyeHeight2(&UserEyeHeight)))
		{
			OutProfile.IPD = UserIPD;
			OutProfile.EyeDepth = UserNeckEyeDistance.x;
			OutProfile.EyeHeight = UserEyeHeight;
			return true;
		}

		return false;
	}

	float FOculusXRHMD::GetVsyncToNextVsync() const
	{
		CheckInGameThread();

		return Settings->VsyncToNextVsync;
	}

	FPerformanceStats FOculusXRHMD::GetPerformanceStats() const
	{
		return PerformanceStats;
	}

	void FOculusXRHMD::GetSuggestedCpuAndGpuPerformanceLevels(EOculusXRProcessorPerformanceLevel& CpuPerfLevel, EOculusXRProcessorPerformanceLevel& GpuPerfLevel)
	{
		CheckInGameThread();
		CpuPerfLevel = Settings->SuggestedCpuPerfLevel;
		GpuPerfLevel = Settings->SuggestedGpuPerfLevel;
	}

	void FOculusXRHMD::SetSuggestedCpuAndGpuPerformanceLevels(EOculusXRProcessorPerformanceLevel CpuPerfLevel, EOculusXRProcessorPerformanceLevel GpuPerfLevel)
	{
		CheckInGameThread();
		FOculusXRHMDModule::GetPluginWrapper().SetSuggestedCpuPerformanceLevel((ovrpProcessorPerformanceLevel)CpuPerfLevel);
		FOculusXRHMDModule::GetPluginWrapper().SetSuggestedGpuPerformanceLevel((ovrpProcessorPerformanceLevel)GpuPerfLevel);
		Settings->SuggestedCpuPerfLevel = CpuPerfLevel;
		Settings->SuggestedGpuPerfLevel = GpuPerfLevel;
	}

	void FOculusXRHMD::SetFoveatedRenderingMethod(EOculusXRFoveatedRenderingMethod InFoveatedRenderingMethod)
	{
#ifdef WITH_OCULUS_BRANCH
		Settings->FoveatedRenderingMethod = InFoveatedRenderingMethod;
		// Don't switch to eye tracked foveated rendering when it's not supported or permissions are denied
		if (InFoveatedRenderingMethod == EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering && !(bEyeTrackedFoveatedRenderingSupported && CheckEyeTrackingPermission(InFoveatedRenderingMethod)))
		{
			return;
		}
#else
		Settings->FoveatedRenderingMethod = EOculusXRFoveatedRenderingMethod::FixedFoveatedRendering;
		if (InFoveatedRenderingMethod == EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering)
		{
			UE_LOG(LogHMD, Warning, TEXT("Eye Tracked Foveated Rendering is not supported on this engine version, using Fixed Foveated Rendering instead"));
		}
#endif // WITH_OCULUS_BRANCH

		FoveatedRenderingMethod = Settings->FoveatedRenderingMethod;
	}

	void FOculusXRHMD::SetFoveatedRenderingLevel(EOculusXRFoveatedRenderingLevel InFoveationLevel, bool isDynamic)
	{
		FoveatedRenderingLevel = Settings->FoveatedRenderingLevel = InFoveationLevel;
		bDynamicFoveatedRendering = Settings->bDynamicFoveatedRendering = isDynamic;
	}

	void FOculusXRHMD::SetColorScaleAndOffset(FLinearColor ColorScale, FLinearColor ColorOffset, bool bApplyToAllLayers)
	{
		CheckInGameThread();
		Settings->bApplyColorScaleAndOffsetToAllLayers = bApplyToAllLayers;
		Settings->ColorScale = LinearColorToOvrpVector4f(ColorScale);
		Settings->ColorOffset = LinearColorToOvrpVector4f(ColorOffset);
	}

	void FOculusXRHMD::SetEnvironmentDepthHandRemoval(bool RemoveHands)
	{
		FOculusXRHMDModule::GetPluginWrapper().SetEnvironmentDepthHandRemoval(RemoveHands);
		bEnvironmentDepthHandRemovalEnabled = RemoveHands;
	}

	void FOculusXRHMD::StartEnvironmentDepth(int CreateFlags)
	{
#if PLATFORM_ANDROID
		// Check and request scene permissions (this is needed for environment depth to work)
		// bind delegate for handling permission request result
		if (!UAndroidPermissionFunctionLibrary::CheckPermission(USE_SCENE_PERMISSION_NAME))
		{
			TArray<FString> Permissions;
			Permissions.Add(USE_SCENE_PERMISSION_NAME);
			UAndroidPermissionCallbackProxy* Proxy = UAndroidPermissionFunctionLibrary::AcquirePermissions(Permissions);
			static FDelegateHandle DelegateHandle;
			DelegateHandle = Proxy->OnPermissionsGrantedDelegate.AddLambda([this, Proxy, CreateFlags](const TArray<FString>& Permissions, const TArray<bool>& GrantResults) {
				int PermIndex = Permissions.Find(USE_SCENE_PERMISSION_NAME);
				if (PermIndex != INDEX_NONE && GrantResults[PermIndex])
				{
					UE_LOG(LogHMD, Verbose, TEXT("%s permission granted"), *USE_SCENE_PERMISSION_NAME);
					StartEnvironmentDepth(CreateFlags);
				}
				else
				{
					UE_LOG(LogHMD, Log, TEXT("%s permission denied"), *USE_SCENE_PERMISSION_NAME);
				}
				Proxy->OnPermissionsGrantedDelegate.Remove(DelegateHandle);
			});
			return;
		}
#endif // PLATFORM_ANDROID

		ExecuteOnRenderThread_DoNotWait([this, CreateFlags]() {
			ovrpEnvironmentDepthTextureDesc DepthTextureDesc;
			if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().InitializeEnvironmentDepth(CreateFlags)) && OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetEnvironmentDepthTextureDesc(&DepthTextureDesc)))
			{
				TArray<ovrpTextureHandle> DepthTextures;
				int32 TextureCount;
				if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetEnvironmentDepthTextureStageCount(&TextureCount)))
				{
					// We don't really do different depth texture formats right now and it's always a
					// single multiview texture, so no need for a separate right eye texture for now.
					// We may need a separate Left/RightDepthTextures in the future.
					DepthTextures.SetNum(TextureCount);

					for (int32 TextureIndex = 0; TextureIndex < TextureCount; TextureIndex++)
					{
						if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().GetEnvironmentDepthTexture(TextureIndex, ovrpEye_Left, &DepthTextures[TextureIndex])))
						{
							UE_LOG(LogHMD, Error, TEXT("Failed to create insight depth texture. NOTE: This causes a leak of %d other texture(s), which will go unused."), TextureIndex);
							return;
						}
					}

					uint32 SizeX = DepthTextureDesc.TextureSize.w;
					uint32 SizeY = DepthTextureDesc.TextureSize.h;
					EPixelFormat DepthFormat = CustomPresent->GetPixelFormat(DepthTextureDesc.Format);
					uint32 NumMips = DepthTextureDesc.MipLevels;
					uint32 NumSamples = DepthTextureDesc.SampleCount;
					uint32 NumSamplesTileMem = 1;
					ETextureCreateFlags DepthTexCreateFlags = TexCreate_ShaderResource | TexCreate_InputAttachmentRead;
					FClearValueBinding DepthTextureBinding = FClearValueBinding::DepthFar;
					ERHIResourceType ResourceType;
					if (DepthTextureDesc.Layout == ovrpLayout_Array)
					{
						ResourceType = RRT_Texture2DArray;
					}
					else
					{
						ResourceType = RRT_Texture2D;
					}

					if (CustomPresent)
					{
						if (!EnvironmentDepthSwapchain.IsEmpty())
						{
							EnvironmentDepthSwapchain.Empty();
						}
						EnvironmentDepthSwapchain = CustomPresent->CreateSwapChainTextures_RenderThread(SizeX, SizeY, DepthFormat, DepthTextureBinding, NumMips, NumSamples, NumSamplesTileMem, ResourceType, DepthTextures, DepthTexCreateFlags, *FString::Printf(TEXT("Oculus Environment Depth Swapchain")));
					}

					FOculusXRHMDModule::GetPluginWrapper().SetEnvironmentDepthHandRemoval(bEnvironmentDepthHandRemovalEnabled);
					FOculusXRHMDModule::GetPluginWrapper().StartEnvironmentDepth();
				}
			}
		});
	}

	void FOculusXRHMD::StopEnvironmentDepth()
	{
		ExecuteOnRenderThread_DoNotWait([this]() {
			ExecuteOnRHIThread_DoNotWait([this]() {
				if (!EnvironmentDepthSwapchain.IsEmpty())
				{
					EnvironmentDepthSwapchain.Empty();
				}
				if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().StopEnvironmentDepth()))
				{
					FOculusXRHMDModule::GetPluginWrapper().DestroyEnvironmentDepth();
				}
			});
		});
	}

	bool FOculusXRHMD::IsEnvironmentDepthStarted()
	{
		return !EnvironmentDepthSwapchain.IsEmpty();
	}

	void FOculusXRHMD::EnableHardOcclusions(bool bEnable)
	{
		bHardOcclusionsEnabled = bEnable;
	}

	bool FOculusXRHMD::DoEnableStereo(bool bStereo)
	{
		CheckInGameThread();

		FSceneViewport* SceneVP = FindSceneViewport();

		if (!Settings->Flags.bHMDEnabled || (SceneVP && !SceneVP->IsStereoRenderingAllowed()))
		{
			bStereo = false;
		}

		if (Settings->Flags.bStereoEnabled && bStereo || !Settings->Flags.bStereoEnabled && !bStereo)
		{
			// already in the desired mode
			return Settings->Flags.bStereoEnabled;
		}

		TSharedPtr<SWindow> Window;

		if (SceneVP)
		{
			Window = SceneVP->FindWindow();
		}

		if (!Window.IsValid() || !SceneVP || !SceneVP->GetViewportWidget().IsValid())
		{
			// try again next frame
			if (bStereo)
			{
				Flags.bNeedEnableStereo = true;

				// a special case when stereo is enabled while window is not available yet:
				// most likely this is happening from BeginPlay. In this case, if frame exists (created in OnBeginPlay)
				// then we need init device and populate the initial tracking for head/hand poses.
				if (Frame.IsValid())
				{
					InitDevice();
				}
			}
			else
			{
				Flags.bNeedDisableStereo = true;
			}

			return Settings->Flags.bStereoEnabled;
		}

		if (OnOculusStateChange(bStereo))
		{
			Settings->Flags.bStereoEnabled = bStereo;

			// Uncap fps to enable FPS higher than 62
			GEngine->bForceDisableFrameRateSmoothing = bStereo;

			// Set MirrorWindow state on the Window
			Window->SetMirrorWindow(bStereo);

			if (bStereo)
			{
				// Start frame
				StartGameFrame_GameThread();
				StartRenderFrame_GameThread();

				// Set viewport size to Rift resolution
				// NOTE: this can enqueue a render frame right away as a result (calling into FOculusXRHMD::BeginRenderViewFamily)
				SceneVP->SetViewportSize(Settings->RenderTargetSize.X, Settings->RenderTargetSize.Y);

				if (Settings->Flags.bPauseRendering)
				{
					GEngine->SetMaxFPS(10);
				}
			}
			else
			{
				// Work around an error log that can happen when enabling stereo rendering again
				if (NextFrameNumber == WaitFrameNumber)
				{
					NextFrameNumber++;
				}

				if (Settings->Flags.bPauseRendering)
				{
					GEngine->SetMaxFPS(0);
				}

				// Restore viewport size to window size
				FVector2D size = Window->GetSizeInScreen();
				SceneVP->SetViewportSize(size.X, size.Y);
				Window->SetViewportSizeDrivenByWindow(true);
			}
		}

		return Settings->Flags.bStereoEnabled;
	}

	void FOculusXRHMD::ResetControlRotation() const
	{
		// Switching back to non-stereo mode: reset player rotation and aim.
		// Should we go through all playercontrollers here?
		APlayerController* pc = GEngine->GetFirstLocalPlayerController(GWorld);
		if (pc)
		{
			// Reset Aim? @todo
			FRotator r = pc->GetControlRotation();
			r.Normalize();
			// Reset roll and pitch of the player
			r.Roll = 0;
			r.Pitch = 0;
			pc->SetControlRotation(r);
		}
	}

	void FOculusXRHMD::UpdateFoveationOffsets_RenderThread()
	{
#ifdef WITH_OCULUS_BRANCH
		CheckInRenderThread();

		SCOPED_NAMED_EVENT(UpdateFoveationOffsets_RenderThread, FColor::Red);

		// Don't execute anything if we're not using Eye Tracked Foveated Rendering (this already takes into account if it's supported or not)
		if (!Frame_RenderThread.IsValid() || Frame_RenderThread->FoveatedRenderingMethod != EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering)
		{
			return;
		}

		const FXRSwapChainPtr& SwapChain = EyeLayer_RenderThread->GetSwapChain();
		if (!SwapChain.IsValid())
		{
			return;
		}

		const FRHITexture2D* const SwapChainTexture = SwapChain->GetTexture2DArray() ? SwapChain->GetTexture2DArray() : SwapChain->GetTexture2D();
		if (!SwapChainTexture)
		{
			return;
		}
		const FIntPoint SwapChainDimensions = SwapChainTexture->GetSizeXY();

		// Enqueue the actual update on the RHI thread, which should execute right before the EndRenderPass call
		ExecuteOnRHIThread_DoNotWait([this, SwapChainDimensions]() {
			SCOPED_NAMED_EVENT(UpdateFoveationEyeTracked_RHIThread, FColor::Red);

			bool bUseOffsets = false;
			FIntPoint Offsets[2];
			// Make sure the the Foveated Rendering Method is still eye tracked at RHI thread time before getting offsets.
			// If the base setting was changed to fixed, even if the frame's setting is still eye tracked, we should switch to fixed. This
			// usually indicates that eye tracking failed on the previous frame, so we don't need to try it again.
			if (Frame_RHIThread.IsValid() && Frame_RHIThread->FoveatedRenderingMethod == EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering && FoveatedRenderingMethod == EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering)
			{
				if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().SetFoveationEyeTracked(ovrpBool_True)))
				{
					ovrpVector2f fovCenter[2];
					ovrpResult Result = FOculusXRHMDModule::GetPluginWrapper().GetFoveationEyeTrackedCenter(fovCenter);
					if (OVRP_SUCCESS(Result))
					{
						Offsets[0].X = fovCenter[0].x * SwapChainDimensions.X / 2;
						Offsets[0].Y = fovCenter[0].y * SwapChainDimensions.Y / 2;
						Offsets[1].X = fovCenter[1].x * SwapChainDimensions.X / 2;
						Offsets[1].Y = fovCenter[1].y * SwapChainDimensions.Y / 2;
						bUseOffsets = true;
					}
					else if (Result != ovrpFailure_DataIsInvalid)
					{
						// Fall back to dynamic FFR High if OVRPlugin call actually fails, since we're not expecting GFR to work again.
						// Additional rendering changes can be made by binding the changes to OculusEyeTrackingStateChanged
						EyeTrackedFoveatedRenderingFallback();
						FOculusEventDelegates::OculusEyeTrackingStateChanged.Broadcast(false);
					}
				}
			}

			if (CustomPresent)
			{
				CustomPresent->UpdateFoveationOffsets_RHIThread(bUseOffsets, Offsets);
			}
		});
#endif // WITH_OCULUS_BRANCH
	}

	class FHardOcclusionsPS : public FGlobalShader
	{
		DECLARE_SHADER_TYPE(FHardOcclusionsPS, Global);

		static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
		{
			FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
		}

		static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
		{
			// This file is already guarded with OCULUS_HMD_SUPPORTED_PLATFORMS
			return true;
		}

		/** Default constructor. */
		FHardOcclusionsPS() {}

		/** Initialization constructor. */
		FHardOcclusionsPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
			: FGlobalShader(Initializer)
		{
			EnvironmentDepthTexture.Bind(Initializer.ParameterMap, TEXT("EnvironmentDepthTexture"));
			EnvironmentDepthSampler.Bind(Initializer.ParameterMap, TEXT("EnvironmentDepthSampler"));
			DepthFactors.Bind(Initializer.ParameterMap, TEXT("DepthFactors"));
			ScreenToDepthMatrices.Bind(Initializer.ParameterMap, TEXT("ScreenToDepthMatrices"));
			DepthViewId.Bind(Initializer.ParameterMap, TEXT("DepthViewId"));
		}

#if UE_VERSION_OLDER_THAN(5, 3, 0)
		template <typename TShaderRHIParamRef>
		void SetParameters(
			FRHICommandListImmediate& RHICmdList,
			const TShaderRHIParamRef ShaderRHI,
			FRHISamplerState* Sampler,
			FRHITexture* Texture,
			const FVector2f& Factors,
			const FMatrix44f ScreenToDepth[ovrpEye_Count],
			const int ViewId)
		{
			SetTextureParameter(RHICmdList, ShaderRHI, EnvironmentDepthTexture, EnvironmentDepthSampler, Sampler, Texture);

			SetShaderValue(RHICmdList, ShaderRHI, DepthFactors, Factors);
			SetShaderValueArray(RHICmdList, ShaderRHI, ScreenToDepthMatrices, ScreenToDepth, ovrpEye_Count);
			SetShaderValue(RHICmdList, ShaderRHI, DepthViewId, ViewId);
		}
#else
		void SetParameters(
			FRHIBatchedShaderParameters& BatchedParameters,
			FRHISamplerState* Sampler,
			FRHITexture* Texture,
			const FVector2f& Factors,
			const FMatrix44f ScreenToDepth[ovrpEye_Count],
			const int ViewId)
		{
			SetTextureParameter(BatchedParameters, EnvironmentDepthTexture, EnvironmentDepthSampler, Sampler, Texture);

			SetShaderValue(BatchedParameters, DepthFactors, Factors);
			SetShaderValueArray(BatchedParameters, ScreenToDepthMatrices, ScreenToDepth, ovrpEye_Count);
			SetShaderValue(BatchedParameters, DepthViewId, ViewId);
		}
#endif

	private:
		LAYOUT_FIELD(FShaderResourceParameter, EnvironmentDepthTexture);
		LAYOUT_FIELD(FShaderResourceParameter, EnvironmentDepthSampler);
		LAYOUT_FIELD(FShaderParameter, DepthFactors);
		LAYOUT_FIELD(FShaderParameter, ScreenToDepthMatrices);
		LAYOUT_FIELD(FShaderParameter, DepthViewId);
	};

	IMPLEMENT_SHADER_TYPE(, FHardOcclusionsPS, TEXT("/Plugin/OculusXR/Private/HardOcclusions.usf"), TEXT("HardOcclusionsPS"), SF_Pixel);

	FMatrix44f MakeProjectionMatrix(ovrpFovf cameraFovAngles)
	{
		const float tanAngleWidth = cameraFovAngles.RightTan + cameraFovAngles.LeftTan;
		const float tanAngleHeight = cameraFovAngles.UpTan + cameraFovAngles.DownTan;

		FMatrix44f Matrix = FMatrix44f::Identity;

		// Scale
		Matrix.M[0][0] = 1.0f / tanAngleWidth;
		Matrix.M[1][1] = 1.0f / tanAngleHeight;

		// Offset
		Matrix.M[0][3] = cameraFovAngles.LeftTan / tanAngleWidth;
		Matrix.M[1][3] = cameraFovAngles.DownTan / tanAngleHeight;
		Matrix.M[2][3] = -1.0f;

		return Matrix;
	}

	FMatrix44f MakeUnprojectionMatrix(ovrpFovf cameraFovAngles)
	{
		FMatrix44f Matrix = FMatrix44f::Identity;

		// Scale
		Matrix.M[0][0] = cameraFovAngles.RightTan + cameraFovAngles.LeftTan;
		Matrix.M[1][1] = cameraFovAngles.UpTan + cameraFovAngles.DownTan;

		// Offset
		Matrix.M[0][3] = -cameraFovAngles.LeftTan;
		Matrix.M[1][3] = -cameraFovAngles.DownTan;
		Matrix.M[2][3] = 1.0;

		return Matrix;
	}

	bool FOculusXRHMD::ComputeEnvironmentDepthParameters_RenderThread(FVector2f& DepthFactors, FMatrix44f ScreenToDepth[ovrpEye_Count], FMatrix44f DepthViewProj[ovrpEye_Count], int& SwapchainIndex)
	{
		float ScreenNearZ = GNearClippingPlane / Frame_RenderThread->WorldToMetersScale;
		ovrpFovf* ScreenFov = Frame_RenderThread->SymmetricFov;

		ovrpEnvironmentDepthFrameDesc DepthFrameDesc[ovrpEye_Count];
		if (FOculusXRHMDModule::GetPluginWrapper().GetEnvironmentDepthFrameDesc(ovrpEye_Left, &DepthFrameDesc[0]) != ovrpSuccess || !DepthFrameDesc[0].IsValid)
		{
			return false;
		}
		if (FOculusXRHMDModule::GetPluginWrapper().GetEnvironmentDepthFrameDesc(ovrpEye_Right, &DepthFrameDesc[1]) != ovrpSuccess || !DepthFrameDesc[1].IsValid)
		{
			return false;
		}

		SwapchainIndex = DepthFrameDesc[0].SwapchainIndex;
		const float WorldToMetersScale = Frame_RenderThread->WorldToMetersScale;

		if (DepthViewProj != nullptr)
		{
			for (int i = 0; i < ovrpEye_Count; ++i)
			{
				ovrpFrustum2f DepthFrustum;
				DepthFrustum.Fov = DepthFrameDesc[i].Fov;
				DepthFrustum.zNear = DepthFrameDesc[i].NearZ * WorldToMetersScale;
				DepthFrustum.zFar = DepthFrameDesc[i].FarZ * WorldToMetersScale;
				FMatrix DepthProjectionMatrix = ToFMatrix(ovrpMatrix4f_Projection(DepthFrustum, true));

				auto DepthOrientation = ToFQuat(DepthFrameDesc[i].CreatePose.Orientation);

				// NOTE: This matrix is the same as applied in SetupViewFrustum in SceneView.cpp
				auto ViewMatrix = DepthOrientation.Inverse().ToMatrix() * FMatrix(FPlane(0, 0, 1, 0), FPlane(1, 0, 0, 0), FPlane(0, 1, 0, 0), FPlane(0, 0, 0, 1));

				ovrpPoseStatef EyePoseState;
				if (OVRP_SUCCESS(FOculusXRHMDModule::GetPluginWrapper().GetNodePoseState3(ovrpStep_Render, Frame_RenderThread->FrameNumber, (ovrpNode)i, &EyePoseState)))
				{
					auto DepthTranslation = ToFVector(DepthFrameDesc[i].CreatePose.Position) * WorldToMetersScale;
					auto EyePos = ToFVector(EyePoseState.Pose.Position) * WorldToMetersScale;
					auto Delta = EyePos - DepthTranslation;

					// NOTE: The view matrix here is relative to the VR camera, this is necessary to support
					// Large Worlds and avoid rounding errors when getting very far away from the origin
					ViewMatrix = ViewMatrix.ConcatTranslation(ViewMatrix.TransformPosition(Delta));
				}

				DepthViewProj[i] = (FMatrix44f)(ViewMatrix * DepthProjectionMatrix);
			}
		}

		// Assume NearZ and FarZ are the same for left and right eyes
		float DepthNearZ = DepthFrameDesc[ovrpEye_Left].NearZ;
		float DepthFarZ = DepthFrameDesc[ovrpEye_Left].FarZ;

		float Scale;
		float Offset;

		if (DepthFarZ < DepthNearZ || (!FGenericPlatformMath::IsFinite(DepthFarZ)))
		{
			// Inf far plane:
			Scale = DepthNearZ;
			Offset = 0.0f;
		}
		else
		{
			// Finite far plane:
			Scale = (DepthFarZ * DepthNearZ) / (DepthFarZ - DepthNearZ);
			Offset = DepthNearZ / (DepthFarZ - DepthNearZ);
		}

		DepthFactors.X = -ScreenNearZ / Scale;
		DepthFactors.Y = Offset * ScreenNearZ / Scale + 1.0f;

		// The pose extrapolated to the predicted display time of the current frame
		FQuat ScreenOrientation = Frame_RenderThread->HeadOrientation;

		for (int i = 0; i < ovrpEye_Count; ++i)
		{
			// Screen To Depth represents the transformation matrix used to map normalised screen UV coordinates to
			// normalised environment depth texture UV coordinates. This needs to account for 2 things:
			// 1. The field of view of the two textures may be different, Unreal typically renders using a symmetric fov.
			//    That is to say the FOV of the left and right eyes is the same. The environment depth on the other hand
			//    has a different FOV for the left and right eyes. So we need to scale and offset accordingly to account
			//    for this difference.
			auto T_ScreenCamera_ScreenNormCoord = MakeUnprojectionMatrix(ScreenFov[i]);
			auto T_DepthNormCoord_DepthCamera = MakeProjectionMatrix(DepthFrameDesc[i].Fov);

			// 2. The headset may have moved in between capturing the environment depth and rendering the frame. We
			//    can only account for rotation of the headset, not translation.
			auto DepthOrientation = ToFQuat(DepthFrameDesc[i].CreatePose.Orientation);
			if (!DepthOrientation.IsNormalized())
			{
				UE_LOG(LogHMD, Error, TEXT("DepthOrientation is not normalized %f %f %f %f"), DepthOrientation.X, DepthOrientation.Y, DepthOrientation.Z, DepthOrientation.W);
				DepthOrientation.Normalize();
			}
			auto ScreenToDepthQuat = ScreenOrientation.Inverse() * DepthOrientation;

			FMatrix44f R_DepthCamera_ScreenCamera = FQuat4f(ScreenToDepthQuat.Y, ScreenToDepthQuat.Z, ScreenToDepthQuat.X, ScreenToDepthQuat.W).GetNormalized().ToMatrix();

			ScreenToDepth[i] = T_DepthNormCoord_DepthCamera * R_DepthCamera_ScreenCamera * T_ScreenCamera_ScreenNormCoord;
		}
		return true;
	}

#if !UE_VERSION_OLDER_THAN(5, 3, 0)
	BEGIN_SHADER_PARAMETER_STRUCT(FDrawRectangleParameters, )
	SHADER_PARAMETER(FVector4f, PosScaleBias)
	SHADER_PARAMETER(FVector4f, UVScaleBias)
	SHADER_PARAMETER(FVector4f, InvTargetSizeAndTextureSize)
	END_SHADER_PARAMETER_STRUCT()
#endif

	void FOculusXRHMD::DrawHmdViewMesh(
		FRHICommandList& RHICmdList,
		float X,
		float Y,
		float SizeX,
		float SizeY,
		float U,
		float V,
		float SizeU,
		float SizeV,
		FIntPoint TargetSize,
		FIntPoint TextureSize,
		int32 StereoView,
		const TShaderRef<FShader>& VertexShader)
	{
		FDrawRectangleParameters Parameters;
		Parameters.PosScaleBias = FVector4f(SizeX, SizeY, X, Y);
		Parameters.UVScaleBias = FVector4f(SizeU, SizeV, U, V);

		Parameters.InvTargetSizeAndTextureSize = FVector4f(
			1.0f / TargetSize.X, 1.0f / TargetSize.Y,
			1.0f / TextureSize.X, 1.0f / TextureSize.Y);

#if UE_VERSION_OLDER_THAN(5, 3, 0)
		SetUniformBufferParameterImmediate(RHICmdList, VertexShader.GetVertexShader(), VertexShader->GetUniformBufferParameter<FDrawRectangleParameters>(), Parameters);
#else
		FRHIBatchedShaderParameters& BatchedParameters = RHICmdList.GetScratchShaderParameters();
		SetUniformBufferParameterImmediate(BatchedParameters, VertexShader->GetUniformBufferParameter<FDrawRectangleParameters>(), Parameters);
		RHICmdList.SetBatchedShaderParameters(VertexShader.GetVertexShader(), BatchedParameters);
#endif
		RendererModule->DrawRectangle(
			RHICmdList,
			X, Y,
			SizeX, SizeY,
			0, 0,
			TextureSize.X, TextureSize.Y,
			TargetSize,
			TextureSize,
			VertexShader);
	}

#if UE_VERSION_OLDER_THAN(5, 3, 0)
	void FOculusXRHMD::RenderHardOcclusions_RenderThread(FRHICommandListImmediate& RHICmdList, const FSceneView& InView)
#else
	void FOculusXRHMD::RenderHardOcclusions_RenderThread(FRHICommandList& RHICmdList, const FSceneView& InView)
#endif
	{
		checkSlow(RHICmdList.IsInsideRenderPass());

		FVector2f DepthFactors;
		FMatrix44f ScreenToDepthMatrices[ovrpEye_Count];
		int SwapchainIndex;

		if (!Frame_RenderThread.IsValid() || InView.bIsSceneCapture || InView.bIsReflectionCapture || InView.bIsPlanarReflection || !ComputeEnvironmentDepthParameters_RenderThread(DepthFactors, ScreenToDepthMatrices, nullptr, SwapchainIndex))
		{
			return;
		}
		if (SwapchainIndex >= EnvironmentDepthSwapchain.Num())
		{
			return;
		}

		FGraphicsPipelineStateInitializer GraphicsPSOInit;
		RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);

		GraphicsPSOInit.BlendState = TStaticBlendState<>::GetRHI();
		GraphicsPSOInit.RasterizerState = TStaticRasterizerState<>::GetRHI();
		GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<>::GetRHI();

		FGlobalShaderMap* GlobalShaderMap = GetGlobalShaderMap(InView.FeatureLevel);
		TShaderMapRef<FScreenPassVS> VertexShader(GlobalShaderMap);
		TShaderMapRef<FHardOcclusionsPS> PixelShader(GlobalShaderMap);

		GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
		GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
		GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
		GraphicsPSOInit.PrimitiveType = PT_TriangleList;

		SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit, 0);

		FRHITexture* DepthTexture = EnvironmentDepthSwapchain[SwapchainIndex];
		FRHISamplerState* DepthSampler = TStaticSamplerState<>::GetRHI();

		FIntPoint TextureSize = DepthTexture->GetDesc().Extent;
		FIntRect ScreenRect = InView.UnscaledViewRect;

#if UE_VERSION_OLDER_THAN(5, 3, 0)
		PixelShader->SetParameters(RHICmdList, PixelShader.GetPixelShader(), DepthSampler, DepthTexture, DepthFactors, ScreenToDepthMatrices, InView.StereoViewIndex);
#else
		FRHIBatchedShaderParameters& BatchedParameters = RHICmdList.GetScratchShaderParameters();
		PixelShader->SetParameters(BatchedParameters, DepthSampler, DepthTexture, DepthFactors, ScreenToDepthMatrices, InView.StereoViewIndex);
		RHICmdList.SetBatchedShaderParameters(PixelShader.GetPixelShader(), BatchedParameters);
#endif

		check(Settings->CurrentShaderPlatform == InView.Family->Scene->GetShaderPlatform());
		if (!IsMobilePlatform(Settings->CurrentShaderPlatform) && InView.StereoViewIndex != INDEX_NONE)
		{
			SCOPED_DRAW_EVENTF(RHICmdList, RenderHardOcclusions_RenderThread, TEXT("View %d"), InView.StereoViewIndex);

			int32 width = ScreenRect.Width() / 2;
			int32 height = ScreenRect.Height();
			int32 x = InView.StereoViewIndex == EStereoscopicEye::eSSE_LEFT_EYE ? 0 : width;
			int32 y = 0;

			DrawHmdViewMesh(
				RHICmdList,
				x, y,
				width, height,
				0, 0,
				TextureSize.X, TextureSize.Y,
				FIntPoint(ScreenRect.Width(), ScreenRect.Height()),
				TextureSize,
				InView.StereoViewIndex,
				VertexShader);
		}
		else
		{
			SCOPED_DRAW_EVENT(RHICmdList, RenderHardOcclusions_RenderThread);

			RendererModule->DrawRectangle(
				RHICmdList,
				0, 0,
				ScreenRect.Width(), ScreenRect.Height(),
				0, 0,
				TextureSize.X, TextureSize.Y,
				FIntPoint(ScreenRect.Width(), ScreenRect.Height()),
				TextureSize,
				VertexShader);
		}
	}

	FSettingsPtr FOculusXRHMD::CreateNewSettings() const
	{
		FSettingsPtr Result(MakeShareable(new FSettings()));
		return Result;
	}

	FGameFramePtr FOculusXRHMD::CreateNewGameFrame() const
	{
		FGameFramePtr Result(MakeShareable(new FGameFrame()));
		Result->FrameNumber = NextFrameNumber;
		Result->WindowSize = CachedWindowSize;
		Result->WorldToMetersScale = CachedWorldToMetersScale;
		Result->NearClippingPlane = GNearClippingPlane;
		// Allow CVars to override the app's foveated rendering settings (set -1 to restore app's setting)
		Result->FoveatedRenderingMethod = CVarOculusFoveatedRenderingMethod.GetValueOnAnyThread() >= 0 ? (EOculusXRFoveatedRenderingMethod)CVarOculusFoveatedRenderingMethod.GetValueOnAnyThread() : FoveatedRenderingMethod.load();
		Result->FoveatedRenderingLevel = CVarOculusFoveatedRenderingLevel.GetValueOnAnyThread() >= 0 ? (EOculusXRFoveatedRenderingLevel)CVarOculusFoveatedRenderingLevel.GetValueOnAnyThread() : FoveatedRenderingLevel.load();
		Result->bDynamicFoveatedRendering = CVarOculusDynamicFoveatedRendering.GetValueOnAnyThread() >= 0 ? (bool)CVarOculusDynamicFoveatedRendering.GetValueOnAnyThread() : bDynamicFoveatedRendering.load();
		Result->Flags.bSplashIsShown = Splash->IsShown();
		return Result;
	}

	void FOculusXRHMD::StartGameFrame_GameThread()
	{
		CheckInGameThread();
		check(Settings.IsValid());

		// TODO: Below check should NOT be limited to bMultiPlayer specificially even though we haven't found a non-MultiPlayer case falling into this case yet.
		//		Remove bMultiPlayer.
		if (bMultiPlayer && !bShouldWait_GameThread)
		{
			return;
		}

		if (!Frame.IsValid())
		{
			Splash->UpdateLoadingScreen_GameThread(); //the result of this is used in CreateGameFrame to know if Frame is a "real" one or a "splash" one.
			if (Settings->Flags.bHMDEnabled)
			{
				Frame = CreateNewGameFrame();
				NextFrameToRender = Frame;

				UE_LOG(LogHMD, VeryVerbose, TEXT("StartGameFrame %u"), Frame->FrameNumber);

				if (!Splash->IsShown())
				{
					FThreadIdleStats::FScopeIdle Scope;

					if (FOculusXRHMDModule::GetPluginWrapper().GetInitialized() && WaitFrameNumber != Frame->FrameNumber)
					{
						SCOPED_NAMED_EVENT(WaitFrame, FColor::Red);

						UE_LOG(LogHMD, Verbose, TEXT("FOculusXRHMDModule::GetPluginWrapper().WaitToBeginFrame %u"), Frame->FrameNumber);

						ovrpResult Result;
						if (OVRP_FAILURE(Result = FOculusXRHMDModule::GetPluginWrapper().WaitToBeginFrame(Frame->FrameNumber)))
						{
							UE_LOG(LogHMD, Error, TEXT("FOculusXRHMDModule::GetPluginWrapper().WaitToBeginFrame %u failed (%d)"), Frame->FrameNumber, Result);
						}
						else
						{
							WaitFrameNumber = Frame->FrameNumber;
							bShouldWait_GameThread = false;
						}
					}

					FOculusXRHMDModule::GetPluginWrapper().Update3(ovrpStep_Render, Frame->FrameNumber, 0.0);
				}
			}

			UpdateStereoRenderingParams();
		}
	}

	void FOculusXRHMD::FinishGameFrame_GameThread()
	{
		CheckInGameThread();

		if (Frame.IsValid())
		{
			UE_LOG(LogHMD, VeryVerbose, TEXT("FinishGameFrame %u"), Frame->FrameNumber);
		}

		Frame.Reset();
	}

	void FOculusXRHMD::StartRenderFrame_GameThread()
	{
		CheckInGameThread();

		if (NextFrameToRender.IsValid() && NextFrameToRender != LastFrameToRender)
		{
			UE_LOG(LogHMD, VeryVerbose, TEXT("StartRenderFrame %u"), NextFrameToRender->FrameNumber);

			LastFrameToRender = NextFrameToRender;
			NextFrameToRender->Flags.bSplashIsShown = Splash->IsShown();

			ovrpXrApi NativeXrApi;
			FOculusXRHMDModule::GetPluginWrapper().GetNativeXrApiType(&NativeXrApi);
			if ((NextFrameToRender->ShowFlags.Rendering || NativeXrApi == ovrpXrApi_OpenXR) && !NextFrameToRender->Flags.bSplashIsShown)
			{
				NextFrameNumber++;
			}

			FSettingsPtr XSettings = Settings->Clone();
			FGameFramePtr XFrame = NextFrameToRender->Clone();
			TArray<FLayerPtr> XLayers;

			XLayers.Empty(LayerMap.Num());

			for (auto Pair : LayerMap)
			{
				XLayers.Emplace(Pair.Value->Clone());
			}

			XLayers.Sort(FLayerPtr_CompareId());

			ExecuteOnRenderThread_DoNotWait([this, XSettings, XFrame, XLayers](FRHICommandListImmediate& RHICmdList) {
				if (XFrame.IsValid())
				{
					Settings_RenderThread = XSettings;
					Frame_RenderThread = XFrame;

					int32 XLayerIndex = 0;
					int32 LayerIndex_RenderThread = 0;
					TArray<FLayerPtr> ValidXLayers;

					while (XLayerIndex < XLayers.Num() && LayerIndex_RenderThread < Layers_RenderThread.Num())
					{
						uint32 LayerIdA = XLayers[XLayerIndex]->GetId();
						uint32 LayerIdB = Layers_RenderThread[LayerIndex_RenderThread]->GetId();

						if (LayerIdA < LayerIdB)
						{
							if (XLayers[XLayerIndex]->Initialize_RenderThread(Settings_RenderThread.Get(), CustomPresent, &DeferredDeletion, RHICmdList))
							{
								ValidXLayers.Add(XLayers[XLayerIndex]);
							}
							XLayerIndex++;
						}
						else if (LayerIdA > LayerIdB)
						{
							DeferredDeletion.AddLayerToDeferredDeletionQueue(Layers_RenderThread[LayerIndex_RenderThread++]);
						}
						else
						{
							if (XLayers[XLayerIndex]->Initialize_RenderThread(Settings_RenderThread.Get(), CustomPresent, &DeferredDeletion, RHICmdList, Layers_RenderThread[LayerIndex_RenderThread].Get()))
							{
								LayerIndex_RenderThread++;
								ValidXLayers.Add(XLayers[XLayerIndex]);
							}
							XLayerIndex++;
						}
					}

					while (XLayerIndex < XLayers.Num())
					{
						if (XLayers[XLayerIndex]->Initialize_RenderThread(Settings_RenderThread.Get(), CustomPresent, &DeferredDeletion, RHICmdList))
						{
							ValidXLayers.Add(XLayers[XLayerIndex]);
						}
						XLayerIndex++;
					}

					while (LayerIndex_RenderThread < Layers_RenderThread.Num())
					{
						DeferredDeletion.AddLayerToDeferredDeletionQueue(Layers_RenderThread[LayerIndex_RenderThread++]);
					}

					Layers_RenderThread = ValidXLayers;

					DeferredDeletion.HandleLayerDeferredDeletionQueue_RenderThread();
				}
			});
		}
	}

	void FOculusXRHMD::FinishRenderFrame_RenderThread(FRDGBuilder& GraphBuilder)
	{
		CheckInRenderThread();

		// TODO: Below check should NOT be limited to bMultiPlayer specificially even though we haven't found a non-MultiPlayer case falling into this case yet.
		//		Remove bMultiPlayer.
		if (bMultiPlayer && !bIsRendering_RenderThread)
		{ //we must keep Frame_RenderThread alive if we haven't started to use it to render yet!
			return;
		}

		if (Frame_RenderThread.IsValid())
		{
			UE_LOG(LogHMD, VeryVerbose, TEXT("FinishRenderFrame %u"), Frame_RenderThread->FrameNumber);

			AddPass(GraphBuilder, RDG_EVENT_NAME("FinishRenderFrame"), [this](FRHICommandListImmediate& RHICmdList) {
				if (Frame_RenderThread->ShowFlags.Rendering)
				{
					for (int32 LayerIndex = 0; LayerIndex < Layers_RenderThread.Num(); LayerIndex++)
					{
						Layers_RenderThread[LayerIndex]->UpdateTexture_RenderThread(Settings_RenderThread.Get(), CustomPresent, RHICmdList);
						Layers_RenderThread[LayerIndex]->UpdatePassthrough_RenderThread(CustomPresent, RHICmdList, Frame_RenderThread.Get());
					}
				}
				Frame_RenderThread.Reset();
			});
		}

		bIsRendering_RenderThread = false;
	}

	void FOculusXRHMD::StartRHIFrame_RenderThread()
	{
		CheckInRenderThread();

		if (Frame_RenderThread.IsValid())
		{
			UE_LOG(LogHMD, VeryVerbose, TEXT("StartRHIFrame %u"), Frame_RenderThread->FrameNumber);

			FSettingsPtr XSettings = Settings_RenderThread->Clone();
			FGameFramePtr XFrame = Frame_RenderThread->Clone();
			TArray<FLayerPtr> XLayers = Layers_RenderThread;

			for (int32 XLayerIndex = 0; XLayerIndex < XLayers.Num(); XLayerIndex++)
			{
				XLayers[XLayerIndex] = XLayers[XLayerIndex]->Clone();
			}

			ExecuteOnRHIThread_DoNotWait([this, XSettings, XFrame, XLayers]() {
				if (XFrame.IsValid())
				{
					Settings_RHIThread = XSettings;
					Frame_RHIThread = XFrame;
					Layers_RHIThread = XLayers;

					ovrpXrApi NativeXrApi;
					FOculusXRHMDModule::GetPluginWrapper().GetNativeXrApiType(&NativeXrApi);
					if ((Frame_RHIThread->ShowFlags.Rendering || NativeXrApi == ovrpXrApi_OpenXR) && !Frame_RHIThread->Flags.bSplashIsShown)
					{
						SCOPED_NAMED_EVENT(BeginFrame, FColor::Red);

						UE_LOG(LogHMD, Verbose, TEXT("FOculusXRHMDModule::GetPluginWrapper().BeginFrame4 %u"), Frame_RHIThread->FrameNumber);

						ovrpResult Result;
						if (OVRP_FAILURE(Result = FOculusXRHMDModule::GetPluginWrapper().BeginFrame4(Frame_RHIThread->FrameNumber, CustomPresent->GetOvrpCommandQueue())))
						{
							UE_LOG(LogHMD, Error, TEXT("FOculusXRHMDModule::GetPluginWrapper().BeginFrame4 %u failed (%d)"), Frame_RHIThread->FrameNumber, Result);
							Frame_RHIThread->ShowFlags.Rendering = false;
						}
						else
						{
#if PLATFORM_ANDROID
							FOculusXRHMDModule::GetPluginWrapper().SetTiledMultiResLevel((ovrpTiledMultiResLevel)Frame_RHIThread->FoveatedRenderingLevel);
							FOculusXRHMDModule::GetPluginWrapper().SetTiledMultiResDynamic(Frame_RHIThread->bDynamicFoveatedRendering ? ovrpBool_True : ovrpBool_False);
#ifdef WITH_OCULUS_BRANCH
							// If we're using eye tracked foveated rendering, set that at the end of the render pass instead (through UpdateFoveationOffsets_RenderThread)
							if (Frame_RHIThread->FoveatedRenderingMethod != EOculusXRFoveatedRenderingMethod::EyeTrackedFoveatedRendering)
							{
								FOculusXRHMDModule::GetPluginWrapper().SetFoveationEyeTracked(ovrpBool_False);
								// Need to also not use offsets when turning off eye tracked foveated rendering
								if (CustomPresent)
								{
									CustomPresent->UpdateFoveationOffsets_RHIThread(false, nullptr);
								}
							}
#endif // WITH_OCULUS_BRANCH
#endif // PLATFORM_ANDROID
						}
					}
				}
			});

			// TODO: Add a hook to resolve discarded frames before we start a new frame.
			// TODO: Below check should NOT be limited to bMultiPlayer specificially even though we haven't found a non-MultiPlayer case falling into this case yet.
			//		Remove bMultiPlayer.
			UE_CLOG(bMultiPlayer && bIsRendering_RenderThread, LogHMD, Verbose, TEXT("Discarded previous frame and started rendering a new frame."));
			bIsRendering_RenderThread = true;
		}
	}

	void FOculusXRHMD::FinishRHIFrame_RHIThread()
	{
		CheckInRHIThread();

		if (Frame_RHIThread.IsValid())
		{
			UE_LOG(LogHMD, VeryVerbose, TEXT("FinishRHIFrame %u"), Frame_RHIThread->FrameNumber);

			ovrpXrApi NativeXrApi;
			FOculusXRHMDModule::GetPluginWrapper().GetNativeXrApiType(&NativeXrApi);
			if ((Frame_RHIThread->ShowFlags.Rendering || NativeXrApi == ovrpXrApi_OpenXR) && !Frame_RHIThread->Flags.bSplashIsShown)
			{
				SCOPED_NAMED_EVENT(EndFrame, FColor::Red);

				TArray<FLayerPtr> Layers = Layers_RHIThread;
				Layers.Sort(FLayerPtr_CompareTotal());
				TArray<const ovrpLayerSubmit*> LayerSubmitPtr;

				int32 LayerNum = Layers.Num();

				LayerSubmitPtr.SetNum(LayerNum);

				int32 FinalLayerNumber = 0;
				for (int32 LayerIndex = 0; LayerIndex < LayerNum; LayerIndex++)
				{
					if (Layers[LayerIndex]->IsVisible())
					{
						LayerSubmitPtr[FinalLayerNumber++] = Layers[LayerIndex]->UpdateLayer_RHIThread(Settings_RHIThread.Get(), Frame_RHIThread.Get(), LayerIndex);
					}
				}

				UE_LOG(LogHMD, Verbose, TEXT("FOculusXRHMDModule::GetPluginWrapper().EndFrame4 %u"), Frame_RHIThread->FrameNumber);
				FOculusXRHMDModule::GetPluginWrapper().SetEyeFovPremultipliedAlphaMode(false);

				ovrpResult Result;
				if (OVRP_FAILURE(Result = FOculusXRHMDModule::GetPluginWrapper().EndFrame4(Frame_RHIThread->FrameNumber, LayerSubmitPtr.GetData(), FinalLayerNumber, CustomPresent->GetOvrpCommandQueue())))
				{
					UE_LOG(LogHMD, Error, TEXT("FOculusXRHMDModule::GetPluginWrapper().EndFrame4 %u failed (%d)"), Frame_RHIThread->FrameNumber, Result);
				}
				else
				{
					for (int32 LayerIndex = 0; LayerIndex < Layers.Num(); LayerIndex++)
					{
						Layers[LayerIndex]->IncrementSwapChainIndex_RHIThread(CustomPresent);
					}
				}
			}
		}

		Frame_RHIThread.Reset();
	}

	void FOculusXRHMD::AddEventPollingDelegate(const FOculusXRHMDEventPollingDelegate& NewDelegate)
	{
		EventPollingDelegates.Add(NewDelegate);
	}

	/// @cond DOXYGEN_WARNINGS

#define BOOLEAN_COMMAND_HANDLER_BODY(ConsoleName, FieldExpr)                        \
	do                                                                              \
	{                                                                               \
		if (Args.Num())                                                             \
		{                                                                           \
			if (Args[0].Equals(TEXT("toggle"), ESearchCase::IgnoreCase))            \
			{                                                                       \
				(FieldExpr) = !(FieldExpr);                                         \
			}                                                                       \
			else                                                                    \
			{                                                                       \
				(FieldExpr) = FCString::ToBool(*Args[0]);                           \
			}                                                                       \
		}                                                                           \
		Ar.Logf(ConsoleName TEXT(" = %s"), (FieldExpr) ? TEXT("On") : TEXT("Off")); \
	}                                                                               \
	while (false)

	void FOculusXRHMD::UpdateOnRenderThreadCommandHandler(const TArray<FString>& Args, UWorld* World, FOutputDevice& Ar)
	{
		CheckInGameThread();

		BOOLEAN_COMMAND_HANDLER_BODY(TEXT("vr.oculus.bUpdateOnRenderThread"), Settings->Flags.bUpdateOnRT);
	}

	void FOculusXRHMD::PixelDensityMinCommandHandler(const TArray<FString>& Args, UWorld*, FOutputDevice& Ar)
	{
		CheckInGameThread();

		if (Args.Num())
		{
			Settings->SetPixelDensityMin(FCString::Atof(*Args[0]));
		}
		Ar.Logf(TEXT("vr.oculus.PixelDensity.min = \"%1.2f\""), Settings->PixelDensityMin);
	}

	void FOculusXRHMD::PixelDensityMaxCommandHandler(const TArray<FString>& Args, UWorld*, FOutputDevice& Ar)
	{
		CheckInGameThread();

		if (Args.Num())
		{
			Settings->SetPixelDensityMax(FCString::Atof(*Args[0]));
		}
		Ar.Logf(TEXT("vr.oculus.PixelDensity.max = \"%1.2f\""), Settings->PixelDensityMax);
	}

	void FOculusXRHMD::HQBufferCommandHandler(const TArray<FString>& Args, UWorld*, FOutputDevice& Ar)
	{
		CheckInGameThread();

		BOOLEAN_COMMAND_HANDLER_BODY(TEXT("vr.oculus.bHQBuffer"), Settings->Flags.bHQBuffer);
	}

	void FOculusXRHMD::HQDistortionCommandHandler(const TArray<FString>& Args, UWorld*, FOutputDevice& Ar)
	{
		CheckInGameThread();

		BOOLEAN_COMMAND_HANDLER_BODY(TEXT("vr.oculus.bHQDistortion"), Settings->Flags.bHQDistortion);
	}

	void FOculusXRHMD::ShowGlobalMenuCommandHandler(const TArray<FString>& Args, UWorld* World, FOutputDevice& Ar)
	{
		CheckInGameThread();

		if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().ShowSystemUI2(ovrpUI::ovrpUI_GlobalMenu)))
		{
			Ar.Logf(TEXT("Could not show platform menu"));
		}
	}

	void FOculusXRHMD::ShowQuitMenuCommandHandler(const TArray<FString>& Args, UWorld* World, FOutputDevice& Ar)
	{
		CheckInGameThread();

		if (OVRP_FAILURE(FOculusXRHMDModule::GetPluginWrapper().ShowSystemUI2(ovrpUI::ovrpUI_ConfirmQuit)))
		{
			Ar.Logf(TEXT("Could not show platform menu"));
		}
	}

#if !UE_BUILD_SHIPPING
	void FOculusXRHMD::StatsCommandHandler(const TArray<FString>& Args, UWorld*, FOutputDevice& Ar)
	{
		CheckInGameThread();

		BOOLEAN_COMMAND_HANDLER_BODY(TEXT("vr.oculus.Debug.bShowStats"), Settings->Flags.bShowStats);
	}

	void FOculusXRHMD::ShowSettingsCommandHandler(const TArray<FString>& Args, UWorld* World, FOutputDevice& Ar)
	{
		Ar.Logf(TEXT("stereo ipd=%.4f\n nearPlane=%.4f"), GetInterpupillaryDistance(), GNearClippingPlane);
	}

	void FOculusXRHMD::IPDCommandHandler(const TArray<FString>& Args, UWorld* World, FOutputDevice& Ar)
	{
		if (Args.Num() > 0)
		{
			SetInterpupillaryDistance(FCString::Atof(*Args[0]));
		}
		Ar.Logf(TEXT("vr.oculus.Debug.IPD = %f"), GetInterpupillaryDistance());
	}

#endif // !UE_BUILD_SHIPPING

	void FOculusXRHMD::LoadFromSettings()
	{
		UOculusXRHMDRuntimeSettings* HMDSettings = GetMutableDefault<UOculusXRHMDRuntimeSettings>();
		check(HMDSettings);

		Settings->Flags.bSupportsDash = HMDSettings->bSupportsDash;
#if PLATFORM_ANDROID
		Settings->Flags.bCompositeDepth = HMDSettings->bCompositeDepthMobile;
#else
		Settings->Flags.bCompositeDepth = HMDSettings->bCompositesDepth;
#endif
		Settings->Flags.bHQDistortion = HMDSettings->bHQDistortion;
		Settings->Flags.bInsightPassthroughEnabled = HMDSettings->bInsightPassthroughEnabled;
#ifdef WITH_OCULUS_BRANCH
		Settings->Flags.bPixelDensityAdaptive = HMDSettings->bDynamicResolution;
#endif
		Settings->SuggestedCpuPerfLevel = HMDSettings->SuggestedCpuPerfLevel;
		Settings->SuggestedGpuPerfLevel = HMDSettings->SuggestedGpuPerfLevel;
		Settings->FoveatedRenderingMethod = HMDSettings->FoveatedRenderingMethod;
		Settings->FoveatedRenderingLevel = HMDSettings->FoveatedRenderingLevel;
		Settings->bDynamicFoveatedRendering = HMDSettings->bDynamicFoveatedRendering;
		Settings->PixelDensityMin = HMDSettings->PixelDensityMin;
		Settings->PixelDensityMax = HMDSettings->PixelDensityMax;
		Settings->ColorSpace = HMDSettings->ColorSpace;
		Settings->ControllerPoseAlignment = HMDSettings->ControllerPoseAlignment;
		Settings->bLateLatching = HMDSettings->bLateLatching;
		Settings->XrApi = HMDSettings->XrApi;
		Settings->bSupportExperimentalFeatures = HMDSettings->bSupportExperimentalFeatures;
		Settings->bSupportEyeTrackedFoveatedRendering = HMDSettings->bSupportEyeTrackedFoveatedRendering;
		Settings->SystemSplashBackground = HMDSettings->SystemSplashBackground;


		Settings->FaceTrackingDataSource.Empty(ovrpFaceConstants_FaceTrackingDataSourcesCount);
		Settings->FaceTrackingDataSource.Append(HMDSettings->FaceTrackingDataSource);
	}

	void FOculusXRHMD::CheckMultiPlayer()
	{
#if WITH_EDITOR && PLATFORM_WINDOWS
		ULevelEditorPlaySettings* PlayInSettings = GetMutableDefault<ULevelEditorPlaySettings>();
		check(PlayInSettings);
		int PlayNumberOfClients = 0;
		PlayInSettings->GetPlayNumberOfClients(PlayNumberOfClients);
		bMultiPlayer = PlayNumberOfClients > 1;
#endif
	}

	/// @endcond

} // namespace OculusXRHMD

#endif //OCULUS_HMD_SUPPORTED_PLATFORMS