// Copyright PICO Technology Co., Ltd. All rights reserved.
// This plugin incorporates portions of the Unreal® Engine. Unreal® is a trademark or registered trademark of Epic Games, Inc. in the United States of America and elsewhere.
// Copyright Epic Games, Inc. All Rights Reserved.

#include "PXR_HMDFunctionLibrary.h"
#include <list>
#include "PXR_HMD.h"
#include "PXR_Log.h"
#include "PXR_HMDRuntimeSettings.h"
#include "PXR_BoundarySystem.h"
#include "PXR_Utils.h"

FPICOXRIPDChangedDelegate UPICOXRHMDFunctionLibrary::PICOXRIPDChangedCallback;
FPICOXRHMD* UPICOXRHMDFunctionLibrary::PICOXRHMD = nullptr;

UPICOXRHMDFunctionLibrary::UPICOXRHMDFunctionLibrary()
{
}

FPICOXRHMD* UPICOXRHMDFunctionLibrary::GetPICOXRHMD()
{
	if (!PICOXRHMD)
	{
		static FName SystemName(TEXT("PICOXRHMD"));
		if (GEngine)
		{
			if (GEngine->XRSystem.IsValid() && (GEngine->XRSystem->GetSystemName() == SystemName))
			{
				PICOXRHMD = static_cast<FPICOXRHMD*>(GEngine->XRSystem.Get());
			}
			if (PICOXRHMD == nullptr)
			{
				PXR_LOGI(PxrUnreal, "GetPICOXRHMD Failed!");
			}
		}
	}
	return PICOXRHMD;
}

FQuat UPICOXRHMDFunctionLibrary::PXR_GetCurrentOrientation()
{
#if PLATFORM_ANDROID
	FVector Position;
	FQuat Orientation;
	GetPICOXRHMD()->GetCurrentPose(IXRTrackingSystem::HMDDeviceId, Orientation, Position);
	return Orientation;
#endif
	return FQuat();
}

FVector UPICOXRHMDFunctionLibrary::PXR_GetCurrentPosition()
{
#if PLATFORM_ANDROID
	FVector Position;
	FQuat Orientation;
	GetPICOXRHMD()->GetCurrentPose(IXRTrackingSystem::HMDDeviceId, Orientation, Position);
	return Position;
#endif
	return FVector();
}

bool UPICOXRHMDFunctionLibrary::PXR_DoesSupportPositionalTracking()
{
#if PLATFORM_ANDROID
	return GetPICOXRHMD()->DoesSupportPositionalTracking();
#endif
	return false;
}

FVector UPICOXRHMDFunctionLibrary::PXR_GetAngularVelocity()
{
#if PLATFORM_ANDROID
	FVector AngularVelocity;
	GetPICOXRHMD()->UPxr_GetAngularVelocity(AngularVelocity);
	return AngularVelocity;
#endif
	return FVector();
}

FVector UPICOXRHMDFunctionLibrary::PXR_GetAcceleration()
{
#if PLATFORM_ANDROID
	FVector Acceleration;
	GetPICOXRHMD()->UPxr_GetAcceleration(Acceleration);
	return Acceleration;
#endif
	return FVector();
}

FVector UPICOXRHMDFunctionLibrary::PXR_GetVelocity()
{
#if PLATFORM_ANDROID
	FVector Velocity;
	GetPICOXRHMD()->UPxr_GetVelocity(Velocity);
	return Velocity;
#endif
	return FVector();
}

FVector UPICOXRHMDFunctionLibrary::PXR_GetAngularAcceleration()
{
#if PLATFORM_ANDROID
	FVector AngularAcceleration;
	GetPICOXRHMD()->UPxr_GetAngularAcceleration(AngularAcceleration);
	return AngularAcceleration;
#endif
	return FVector();
}

EHMDWornState::Type UPICOXRHMDFunctionLibrary::PXR_GetHMDWornState()
{
#if PLATFORM_ANDROID
	return GetPICOXRHMD()->GetHMDWornState();
#endif
	return EHMDWornState::Type::Unknown;
}

bool UPICOXRHMDFunctionLibrary::PXR_ResetHMDSensor()
{
#if PLATFORM_ANDROID
	GetPICOXRHMD()->ResetOrientationAndPosition(0);
	return true;
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_GetFieldOfView(float& HFOVInDegrees, float& VFOVInDegrees)
{
#if PLATFORM_ANDROID
	GetPICOXRHMD()->GetFieldOfView(HFOVInDegrees, VFOVInDegrees);
	return true;
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_SetFieldOfView(EPICOXREyeType Eye, float FovLeftInDegrees, float FovRightInDegrees, float FovUpInDegrees, float FovDownInDegrees)
{
#if PLATFORM_ANDROID
	return GetPICOXRHMD()->UPxr_SetFieldOfView(Eye, FovLeftInDegrees, FovRightInDegrees, FovUpInDegrees, FovDownInDegrees) ? false : true;
#endif
	return false;
}

float UPICOXRHMDFunctionLibrary::PXR_GetIPD()
{
#if PLATFORM_ANDROID
	return GetPICOXRHMD()->UPxr_GetIPD();
#endif
	return 0;
}

void UPICOXRHMDFunctionLibrary::PXR_IPDChangedDelegates(FPICOXRIPDChangedDelegate OnPICOXRIPDChanged)
{
#if PLATFORM_ANDROID
	PICOXRIPDChangedCallback = OnPICOXRIPDChanged;
#endif
}

FString UPICOXRHMDFunctionLibrary::PXR_GetDeviceModel()
{
#if PLATFORM_ANDROID
	return GetPICOXRHMD()->UPxr_GetDeviceModel();
#endif
	return "";
}

float UPICOXRHMDFunctionLibrary::PXR_GetCurrentDisplayFrequency()
{
	float frequency = 1.0f;
#if PLATFORM_ANDROID
    FPICOXRHMDModule::GetPluginWrapper().GetConfigFloat(PxrConfigType::PXR_DISPLAY_REFRESH_RATE, &frequency);
#endif
	return frequency;
}

void UPICOXRHMDFunctionLibrary::PXR_SetCPUAndGPULevels(int32 CPULevel, int32 GPULevel)
{
#if PLATFORM_ANDROID
    FPICOXRHMDModule::GetPluginWrapper().SetPerformanceLevels(PxrPerfSettings::PXR_PERF_SETTINGS_CPU,CPULevel);
    FPICOXRHMDModule::GetPluginWrapper().SetPerformanceLevels(PxrPerfSettings::PXR_PERF_SETTINGS_GPU,GPULevel);
#endif
}

bool UPICOXRHMDFunctionLibrary::PXR_SetPerformanceLevel(EPerformanceSettingTypes SettingType, EPerfSettingsLevel Level)
{
#if PLATFORM_ANDROID
	const int32 SettingLevel = static_cast<int32>(Level);
	switch (SettingType)
	{
	case EPerformanceSettingTypes::CPULevel:
		{
			return FPICOXRHMDModule::GetPluginWrapper().SetPerformanceLevels(PxrPerfSettings::PXR_PERF_SETTINGS_CPU, SettingLevel) ? false : true;
		}
	case EPerformanceSettingTypes::GPULevel:
		{
			return FPICOXRHMDModule::GetPluginWrapper().SetPerformanceLevels(PxrPerfSettings::PXR_PERF_SETTINGS_GPU, SettingLevel) ? false : true;
		}
	default:
		return false;
	}
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_GetPerformanceLevel(EPerformanceSettingTypes SettingType, EPerfSettingsLevel& Level)
{
#if PLATFORM_ANDROID
	int32 SettingLevel;
	switch (SettingType)
	{
	case EPerformanceSettingTypes::CPULevel:
		{
			bool result = FPICOXRHMDModule::GetPluginWrapper().GetPerformanceLevels(PxrPerfSettings::PXR_PERF_SETTINGS_CPU, &SettingLevel) ? false : true;
			Level = static_cast<EPerfSettingsLevel>(SettingLevel);
			return result;
		}
	case EPerformanceSettingTypes::GPULevel:
		{
			bool result = FPICOXRHMDModule::GetPluginWrapper().GetPerformanceLevels(PxrPerfSettings::PXR_PERF_SETTINGS_GPU, &SettingLevel) ? false : true;
			Level = static_cast<EPerfSettingsLevel>(SettingLevel);
			return result;
		}
	default:
		return false;
	}
#endif
	return false;
}

void UPICOXRHMDFunctionLibrary::PXR_GetCPUAndGPULevels(int32& CPULevel, int32& GPULevel)
{
#if PLATFORM_ANDROID
    int32 cpuLevel, gpuLevel = -1;
    FPICOXRHMDModule::GetPluginWrapper().GetPerformanceLevels(PXR_PERF_SETTINGS_CPU, &cpuLevel);
    FPICOXRHMDModule::GetPluginWrapper().GetPerformanceLevels(PXR_PERF_SETTINGS_GPU, &gpuLevel);

    CPULevel = cpuLevel;
    GPULevel = gpuLevel;
#endif
}

float UPICOXRHMDFunctionLibrary::PXR_GetSystemDisplayFrequency()
{
	float frequency = 0.f;
#if PLATFORM_ANDROID
    FPICOXRHMDModule::GetPluginWrapper().GetConfigFloat(PxrConfigType::PXR_GET_DISPLAY_RATE, &frequency);
#endif
	return frequency;
}

void UPICOXRHMDFunctionLibrary::PXR_SetSystemDisplayFrequency(float Rate)
{
#if PLATFORM_ANDROID
    FPICOXRHMDModule::GetPluginWrapper().SetDisplayRefreshRate(Rate);
#endif
}

void UPICOXRHMDFunctionLibrary::PXR_SetColorScaleAndOffset(FLinearColor ColorScale, FLinearColor ColorOffset, bool bApplyToAllLayers)
{
#if PLATFORM_ANDROID
    GetPICOXRHMD()->SetColorScaleAndOffset(ColorScale,ColorOffset,bApplyToAllLayers);
#endif
}

bool UPICOXRHMDFunctionLibrary::GetFocusState()
{
#if PLATFORM_ANDROID
	const FPICOXRHMD* const PICOXRHMDInstance = GetPICOXRHMD();
	if (PICOXRHMDInstance != nullptr && PICOXRHMDInstance->IsHMDEnabled())
	{
		return PICOXRHMDInstance->inputFocusState;
	}
#endif
	return false;
}

UPICOXRBoundarySystem* UPICOXRHMDFunctionLibrary::GetBoundarySystemInterface()
{
	return UPICOXRBoundarySystem::GetInstance();
}

bool UPICOXRHMDFunctionLibrary::PXR_GetBoundaryConfigured()
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_GetConfigured();
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_GetBoundaryEnabled()
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_GetEnabled();
#endif
	return false;
}

void UPICOXRHMDFunctionLibrary::PXR_SetBoundaryVisible(bool NewVisible)
{
#if PLATFORM_ANDROID
	GetBoundarySystemInterface()->UPxr_SetVisible(NewVisible);
#endif
}

bool UPICOXRHMDFunctionLibrary::PXR_GetBoundaryVisible()
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_GetVisible();
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_BoundaryTestNode(EPICOXRNodeType DeviceType, EPICOXRBoundaryType BoundaryType, bool& IsTriggering, float& ClosestDistance, FVector& ClosestPoint, FVector& ClosestPointNormal)
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_TestNode(static_cast<int32>(DeviceType), BoundaryType == EPICOXRBoundaryType::PlayArea, IsTriggering, ClosestDistance, ClosestPoint, ClosestPointNormal);
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_BoundaryTestPoint(FVector Point, EPICOXRBoundaryType BoundaryType, bool& IsTriggering, float& ClosestDistance, FVector& ClosestPoint, FVector& ClosestPointNormal)
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_TestPoint(Point, BoundaryType == EPICOXRBoundaryType::PlayArea, IsTriggering, ClosestDistance, ClosestPoint, ClosestPointNormal);
#endif
	return false;
}

TArray<FVector> UPICOXRHMDFunctionLibrary::PXR_GetBoundaryGeometry(EPICOXRBoundaryType BoundaryType)
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_GetGeometry(BoundaryType == EPICOXRBoundaryType::PlayArea);
#endif
	return TArray<FVector>();
}

FVector UPICOXRHMDFunctionLibrary::PXR_GetBoundaryDimensions(EPICOXRBoundaryType BoundaryType)
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_GetDimensions(BoundaryType == EPICOXRBoundaryType::PlayArea);
#endif
	return FVector();
}

int UPICOXRHMDFunctionLibrary::PXR_SetSeeThroughBackground(bool Value)
{
#if PLATFORM_ANDROID
	return GetBoundarySystemInterface()->UPxr_SetSeeThroughBackground(Value);
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_GetFoveationLevel(EPICOXRFoveationLevel &FoveationLevel)
{
#if PLATFORM_ANDROID
	int32 Foveation = -1;
	Foveation = (int32)FPICOXRHMDModule::GetPluginWrapper().GetFoveationLevel();
	switch (Foveation)
	{
	case -1:
		FoveationLevel = EPICOXRFoveationLevel::None;
		PXR_LOGI(PxrUnreal, "Foveation disabled!");
		return false;
	case 0:
		FoveationLevel = EPICOXRFoveationLevel::Low;
		return true;
	case 1:
		FoveationLevel = EPICOXRFoveationLevel::Medium;
		return true;
	case 2:
		FoveationLevel = EPICOXRFoveationLevel::High;
		return true;
	case 3:
		FoveationLevel = EPICOXRFoveationLevel::TopHigh;
		return true;
	default:
		return false;
		break;
	}
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_SetFoveationLevel(EPICOXRFoveationLevel InLevel)
{
#if PLATFORM_ANDROID
	PxrFoveationLevel Level = PxrFoveationLevel::PXR_FOVEATION_LEVEL_NONE;
	switch (InLevel)
	{
	case EPICOXRFoveationLevel::None:
		Level = PxrFoveationLevel::PXR_FOVEATION_LEVEL_NONE;
		break;
	case EPICOXRFoveationLevel::Low:
		Level = PxrFoveationLevel::PXR_FOVEATION_LEVEL_LOW;
		break;
	case EPICOXRFoveationLevel::Medium:
		Level = PxrFoveationLevel::PXR_FOVEATION_LEVEL_MID;
		break;
	case EPICOXRFoveationLevel::High:
		Level = PxrFoveationLevel::PXR_FOVEATION_LEVEL_HIGH;
		break;
	case EPICOXRFoveationLevel::TopHigh:
		Level = PxrFoveationLevel::PXR_FOVEATION_LEVEL_TOP_HIGH;
		break;
	default:
		break;
	}
	if (FPICOXRHMDModule::GetPluginWrapper().SetFoveationLevel(Level) == 0)
	{
		FPICOXRHMD* PICOHMD = GetPICOXRHMD();
		PICOHMD->GameSettings->FoveatedRenderingLevel = Level;
		return true;
	}
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_SetFoveationParameter(FVector2D FoveationGainValue, float FoveationAreaValue, float FoveationMinimumValue)
{
#if PLATFORM_ANDROID
	PxrFoveationParams FoveationParams;
	FoveationParams.foveationGainX = FoveationGainValue.X;
	FoveationParams.foveationGainY = FoveationGainValue.Y;
	FoveationParams.foveationArea = FoveationAreaValue;
	FoveationParams.foveationMinimum = FoveationMinimumValue;
	if (FPICOXRHMDModule::GetPluginWrapper().SetFoveationParams(FoveationParams) == 0)
	{
		return true;
	}
#endif
	return false;
}

int UPICOXRHMDFunctionLibrary::PXR_SetSensorLostCustomMode(bool Value)
{
#if PLATFORM_ANDROID
    return FPICOXRHMDModule::GetPluginWrapper().SetSensorLostCustomMode(Value);
#endif
	return 0;
}

int UPICOXRHMDFunctionLibrary::PXR_SetSensorLostCMST(bool Value)
{
#if PLATFORM_ANDROID
    return FPICOXRHMDModule::GetPluginWrapper().SetSensorLostCMST(Value);
#endif
	return 0;
}

void UPICOXRHMDFunctionLibrary::PXR_GetVFov(float& VFOVInDegrees)
{
#if PLATFORM_ANDROID
	float drop;
	GetPICOXRHMD()->GetFieldOfView(drop, VFOVInDegrees);
#endif
}

void UPICOXRHMDFunctionLibrary::PXR_GetHFov(float& HFOVInDegrees)
{
#if PLATFORM_ANDROID
	float drop;
	GetPICOXRHMD()->GetFieldOfView(HFOVInDegrees, drop);
#endif
}

bool UPICOXRHMDFunctionLibrary::PXR_GetDisplayFrequenciesAvailable(int& Count, TArray<float>& AvailableRates)
{
	bool result = false;
#if PLATFORM_ANDROID
    float* temp = nullptr;
    uint32_t* number = (uint32_t*)(&Count);
    if (!FPICOXRHMDModule::GetPluginWrapper().GetDisplayRefreshRatesAvailable(number, &temp))
    {
        if (!Count) { return result; }
        AvailableRates.Init(0, Count);
        FMemory::Memcpy(AvailableRates.GetData(), temp, sizeof(float) * Count);
        result = true;
    }
#endif
	return result;
}

bool UPICOXRHMDFunctionLibrary::PXR_SetExtraLatencyMode(int Mode)
{
#if PLATFORM_ANDROID
    return FPICOXRHMDModule::GetPluginWrapper().SetExtraLatencyMode(Mode);
#endif
	return false;
}

UPICOXREventManager* UPICOXRHMDFunctionLibrary::PXR_GetEventManager()
{
	return UPICOXREventManager::GetInstance();
}

void UPICOXRHMDFunctionLibrary::PXR_GetPredictedMainSensorState(FPxrSensorState& sensorState, int& sensorFrameIndex) {
#if PLATFORM_ANDROID
	if (FPICOXRVersionHelper::IsThisVersionOrGreater(0x2000201))
	{
        double predictTimeMs = 0.0;
        FPICOXRHMDModule::GetPluginWrapper().GetPredictedDisplayTime(&predictTimeMs);
        PxrSensorState2 sensorState2;
        FPICOXRHMDModule::GetPluginWrapper().GetPredictedMainSensorState2(predictTimeMs, &sensorState2, &sensorFrameIndex);
        sensorState.status = sensorState2.status;
        sensorState.poseQuat.X = sensorState2.pose.orientation.x;
        sensorState.poseQuat.Y = sensorState2.pose.orientation.y;
        sensorState.poseQuat.Z = sensorState2.pose.orientation.z;
        sensorState.poseQuat.W = sensorState2.pose.orientation.w;
        sensorState.poseVector.X = sensorState2.pose.position.x;
        sensorState.poseVector.Y = sensorState2.pose.position.y;
        sensorState.poseVector.Z = sensorState2.pose.position.z;
        sensorState.globalPoseQuat.X = sensorState2.globalPose.orientation.x;
        sensorState.globalPoseQuat.Y = sensorState2.globalPose.orientation.y;
        sensorState.globalPoseQuat.Z = sensorState2.globalPose.orientation.z;
        sensorState.globalPoseQuat.W = sensorState2.globalPose.orientation.w;
        sensorState.globalPoseVector.X = sensorState2.globalPose.position.x;
        sensorState.globalPoseVector.Y = sensorState2.globalPose.position.y;
        sensorState.globalPoseVector.Z = sensorState2.globalPose.position.z;
        sensorState.angularVelocity.X = sensorState2.angularVelocity.x;
        sensorState.angularVelocity.Y = sensorState2.angularVelocity.y;
        sensorState.angularVelocity.Z = sensorState2.angularVelocity.z;
        sensorState.linearVelocity.X = sensorState2.linearVelocity.x;
        sensorState.linearVelocity.Y = sensorState2.linearVelocity.y;
        sensorState.linearVelocity.Z = sensorState2.linearVelocity.z;
        sensorState.angularAcceleration.X = sensorState2.angularAcceleration.x;
        sensorState.angularAcceleration.Y = sensorState2.angularAcceleration.y;
        sensorState.angularAcceleration.Z = sensorState2.angularAcceleration.z;
        sensorState.linearAcceleration.X = sensorState2.linearAcceleration.x;
        sensorState.linearAcceleration.Y = sensorState2.linearAcceleration.y;
        sensorState.linearAcceleration.Z = sensorState2.linearAcceleration.z;
        sensorState.poseTimeStampNs = sensorState2.poseTimeStampNs;
    }
#endif
}

bool UPICOXRHMDFunctionLibrary::PXR_QueryDeviceAbilities(EPICOXRDeviceAbilities DeviceAbility)
{
#if PLATFORM_ANDROID
	if (FPICOXRVersionHelper::IsThisVersionOrGreater(0x2000304))
    {
        PxrTrackingModeFlags SupportTrackingMode;
        FPICOXRHMDModule::GetPluginWrapper().GetTrackingMode(&SupportTrackingMode);
        switch (DeviceAbility)
        {
        case EPICOXRDeviceAbilities::TRACKING_MODE_ROTATION_BIT:
            {
                return (PXR_TRACKING_MODE_ROTATION_BIT & SupportTrackingMode)? true:false;
            }
            break;
        case EPICOXRDeviceAbilities::TRACKING_MODE_POSITION_BIT:
            {
                return (PXR_TRACKING_MODE_POSITION_BIT & SupportTrackingMode)? true:false;
            }
            break;
        case EPICOXRDeviceAbilities::TRACKING_MODE_EYE_BIT:
            {
                return (PXR_TRACKING_MODE_EYE_BIT & SupportTrackingMode)? true:false;
            }
            break;
        case EPICOXRDeviceAbilities::TRACKING_MODE_FACE_BIT:
            {
                return (PXR_TRACKING_MODE_FACE_BIT & SupportTrackingMode)? true:false;
            }
            break;
        case EPICOXRDeviceAbilities::TRACKING_MODE_VCMOTOR_BIT:
            {
                return (PXR_TRACKING_MODE_VCMOTOR_BIT & SupportTrackingMode)? true:false;
            }
            break;
        case EPICOXRDeviceAbilities::TRACKING_MODE_HAND_BIT:
            {
                return (PXR_TRACKING_MODE_HAND_BIT & SupportTrackingMode)? true:false;
            }
            break;
        default:
            ;
        }
    }
#endif

	return false;
}

void UPICOXRHMDFunctionLibrary::PXR_SetLateLatchingEnable(bool Value)
{
    IConsoleVariable* Variable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.EnableLateLatching"));
    if (Variable)
    {
        Variable->Set(Value ? 1 : 0);
    }
}

void UPICOXRHMDFunctionLibrary::PXR_SetBaseRotationAndBaseOffsetInMeters(FRotator Rotation, FVector BaseOffsetInMeters, EOrientPositionSelector::Type Options)
{
#if PLATFORM_ANDROID
	FPICOXRHMD* PICOHMD = GetPICOXRHMD();
	if (PICOHMD != nullptr)
	{
		if ((Options == EOrientPositionSelector::Orientation) || (Options == EOrientPositionSelector::OrientationAndPosition))
		{
			PICOHMD->SetBaseRotation(Rotation);
		}
		if ((Options == EOrientPositionSelector::Position) || (Options == EOrientPositionSelector::OrientationAndPosition))
		{
			PICOHMD->SetBaseOffsetInMeters(BaseOffsetInMeters);
		}
	}
#endif // PICO_HMD_SUPPORTED_PLATFORMS
}

void UPICOXRHMDFunctionLibrary::PXR_GetBaseRotationAndBaseOffsetInMeters(FRotator& OutRotation, FVector& OutBaseOffsetInMeters)
{
#if PLATFORM_ANDROID
	FPICOXRHMD* PICOHMD = GetPICOXRHMD();
	if (PICOHMD != nullptr)
	{
		OutRotation = PICOHMD->GetBaseRotation();
		OutBaseOffsetInMeters = PICOHMD->GetBaseOffsetInMeters();
	}
	else
	{
		OutRotation = FRotator::ZeroRotator;
		OutBaseOffsetInMeters = FVector::ZeroVector;
	}
#endif // PICO_HMD_SUPPORTED_PLATFORMS
}

bool UPICOXRHMDFunctionLibrary::PXR_GetHmdBatteryLevel(int32 &Battery)
{
#if PLATFORM_ANDROID
	FPICOXRHMD* PICOHMD = GetPICOXRHMD();
	if (PICOHMD == nullptr)
	{
		return false;
	}
	if (FPICOXRVersionHelper::IsThisVersionOrGreater(0x200030B))
	{
		return PICOHMD->UpdateHMDBatteryLevelFromPollEvent(Battery);
	}
	else
	{
		return PICOHMD->UpdateHMDBatteryLevelFromJava(Battery);
	}
#endif
	return false;
}

bool UPICOXRHMDFunctionLibrary::PXR_SelectCoordinateSpace(const EPICOXRCoordinateType CoordinateType)
{
	FPICOXRHMD* PICOHMD = GetPICOXRHMD();
	if (PICOHMD != nullptr)
	{
		return PICOHMD->SetCurrentCoordinateType(CoordinateType);
	}
	return true;
}

bool UPICOXRHMDFunctionLibrary::PXR_SetFoveatedRenderingMode(EFoveationRenderingMode Mode)
{
#ifdef PICO_CUSTOM_ENGINE
	GetPICOXRHMD()->SetFoveationRenderingMode(Mode);
	return FPICOXRHMDModule::GetPluginWrapper().SetEyeTrackingFoveationRenderingState(Mode == EFoveationRenderingMode::EyeTrackingFoveationRendering ? true : false) >= 0;
#else
	return false;
#endif
}

float UPICOXRHMDFunctionLibrary::PXR_GetToDeltaSensorY()
{
    float ToDeltaSensorY = 0.0f;
    FPICOXRHMDModule::GetPluginWrapper().GetConfigFloat(PxrConfigType::PXR_TO_DELTA_SENSOR_Y, &ToDeltaSensorY);
    return ToDeltaSensorY;
}

float UPICOXRHMDFunctionLibrary::PXR_GetPredictedDisplayTime()
{
    double PredictTimeMs = 0.0f;
    FPICOXRHMDModule::GetPluginWrapper().GetPredictedDisplayTime(&PredictTimeMs);
    return PredictTimeMs;
}

FString UPICOXRHMDFunctionLibrary::PXR_GetDeviceName()
{
	FString result = FString("");
#if PLATFORM_ANDROID
	if (JNIEnv* Env = FAndroidApplication::GetJavaEnv())
	{
		static jmethodID Method = FJavaWrapper::FindMethod(Env, FJavaWrapper::GameActivityClassID, "getPXRProductName", "()Ljava/lang/String;", false);
		jstring JavaString = (jstring)FJavaWrapper::CallObjectMethod(Env, FJavaWrapper::GameActivityThis, Method);
		if (JavaString != NULL)
		{
			const char* JavaChars = Env->GetStringUTFChars(JavaString, 0);
			result = FString(UTF8_TO_TCHAR(JavaChars));
			Env->ReleaseStringUTFChars(JavaString, JavaChars);
			Env->DeleteLocalRef(JavaString);
		}
	}
#endif
	return result;
}