PixoVRFunctionLibrary.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "Utilities/PixoVRFunctionLibrary.h"
#include "HeadMountedDisplayFunctionLibrary.h"
#include "Kismet/GameplayStatics.h"
#include "Misc/Paths.h"
#include "HAL/PlatformFilemanager.h"
#include "GenericPlatform/GenericPlatformFile.h"
#include "Misc/CString.h"
#include "Misc/FileHelper.h"
#include "Utilities/PixoSHA256.h"
#include "Misc/CString.h"
#include "Login/PixoVRLoginCache.h"
#include "Kismet/GameplayStatics.h"
#include "PixoCoreSettings.h"
#if PLATFORM_ANDROID
#include "Android/AndroidPlatformMisc.h"
#endif
 
#if WITH_EDITOR
#include "Editor/EditorEngine.h"
#endif
 
DEFINE_LOG_CATEGORY(PixoVRFunctionLibrary);
 
const FString CacheFileName = TEXT("Cache");
 
bool ExportToCSV(FString ThePath, FString textbody, FString fileName, FString folderName, bool OverwriteFile);
 
USceneComponent* UPixoVRFunctionLibrary::AddSceneComponentByClass(UObject* Outer, TSubclassOf<USceneComponent> Class,
                                                                  const FTransform& ComponentRelativeTransform)
{
    if (Class != nullptr && Outer != nullptr)
    {
        USceneComponent* Component = NewObject<USceneComponent>(Outer, *Class);
        if (Component != nullptr)
        {
            if (USceneComponent* ParentComp = Cast<USceneComponent>(Outer))
            {
                Component->SetupAttachment(ParentComp);
            }
 
            Component->RegisterComponent();
            Component->SetRelativeTransform(ComponentRelativeTransform);
 
            return Component;
        }
        return nullptr;
    }
 
    return nullptr;
}
 
FString UPixoVRFunctionLibrary::NewLineCharacter()
{
    return TEXT("\n");
}
 
bool UPixoVRFunctionLibrary::ExportToCSVToSpecifiedPath(FString FilePath, FString Textbody, FString FileName,
                                                        FString FolderName, bool OverwriteFile)
{
    FString ThePath = FilePath;
    return ExportToCSV(ThePath, Textbody, FileName, FolderName, OverwriteFile);
}
 
FString UPixoVRFunctionLibrary::GetHMDFullDeviceName()
{
    FString deviceName = TEXT("None");
 
#if PLATFORM_ANDROID
    deviceName = FAndroidMisc::GetDeviceModel();
#else
    deviceName = UHeadMountedDisplayFunctionLibrary::GetHMDDeviceName().ToString();
#endif
 
    return deviceName; //Possible values: SteamVR, Vive Focus Plus, VIVE Focus 3, Quest, Pico Neo 2, Pico Neo 3
}
 
void UPixoVRFunctionLibrary::GetVersionName(FString& Version)
{
    FString ValueReceived1;
    GConfig->GetString(
        TEXT("/Script/EngineSettings.GeneralProjectSettings"),
//      TEXT("VersionName"),
// VersionName does not exist anymore, Use ProjectVersion key
        TEXT("ProjectVersion"),
        Version,
        GGameIni
    );
}
 
bool UPixoVRFunctionLibrary::GetKillSwitchValues(FString& MonthDayYear)
{
    FString ValueReceived1;
    bool bEnabled = false;
    if (GConfig)
    {
        GConfig->GetBool(
            TEXT("/Script/Pixo.TerminateValues"),
            TEXT("bEnabled"),
            bEnabled,
            GEngineIni
        );
        GConfig->GetString(
            TEXT("/Script/Pixo.TerminateValues"),
            TEXT("MonthDayYear"),
            MonthDayYear,
            GEngineIni
        );
    }
    return bEnabled;
}
 
FPixoLoginInfo UPixoVRFunctionLibrary::EncryptLoginInfo(const FPixoLoginInfo& LoginInfo, const FString& Password)
{
    FPixoLoginInfo Tmp = LoginInfo;
 
    PIXOVR_BYTE Digest[SHA256_BLOCK_SIZE] = {0};
    const ANSICHAR* password = TCHAR_TO_ANSI(*Password);
    SHA256_CTX ctx;
    sha256_init(&ctx);
    sha256_update(&ctx, (const PIXOVR_BYTE*)password, static_cast<size_t>(TCString<ANSICHAR>::Strlen(password)));
    sha256_final(&ctx, Digest);
 
    TCHAR Buffer[2 * SHA256_BLOCK_SIZE + 1];
    for (int i = 0; i < SHA256_BLOCK_SIZE; i++)
    {
        FCString::Sprintf(Buffer + 2 * i, TEXT("%02x"), Digest[i]);
    }
    FString Signature(Buffer);
    Tmp.Password = Signature;
    Tmp.Encrypted = true;
 
    return Tmp;
}
 
 
bool UPixoVRFunctionLibrary::LoadAuthFromJSON(FPixoLoginInfo& LoginInfo)
{
    UPixoVRLoginCache* LoginCache = Cast<UPixoVRLoginCache>(UGameplayStatics::LoadGameFromSlot(CacheFileName, 0));
    if (LoginCache)
    {
        LoginInfo = LoginCache->LoginInfo;
        return true;
    }
 
    return false;
}
 
bool UPixoVRFunctionLibrary::SaveAuthToJSON(const FPixoLoginInfo& LoginInfo)
{
    UPixoVRLoginCache* SaveGame = NewObject<UPixoVRLoginCache>();
    SaveGame->LoginInfo = LoginInfo;
 
    bool Result = UGameplayStatics::SaveGameToSlot(SaveGame, CacheFileName, 0);
    return Result;
}
 
bool UPixoVRFunctionLibrary::CompareAuthJSON(const FPixoLoginInfo& LoginInfo)
{
    UPixoVRLoginCache* LoginCache = Cast<UPixoVRLoginCache>(UGameplayStatics::LoadGameFromSlot(CacheFileName, 0));
    if (LoginCache)
    {
        return (LoginInfo == LoginCache->LoginInfo);
    }
 
    return false;
}
 
bool UPixoVRFunctionLibrary::DeleteAuthJSON()
{
    bool Result = UGameplayStatics::DeleteGameInSlot(CacheFileName, 0);
 
    return Result;
}
 
bool UPixoVRFunctionLibrary::CheckAuthJSON()
{
    return UGameplayStatics::DoesSaveGameExist(CacheFileName, 0);
}
 
bool UPixoVRFunctionLibrary::ExportToCSVToProjectRootDirectory(FString Textbody, FString FileName, FString FolderName,
                                                               bool OverwriteFile)
{
    FString ThePath = FPaths::ConvertRelativePathToFull(FPaths::RootDir());
    return ExportToCSV(ThePath, Textbody, FileName, FolderName, OverwriteFile);
}
 
bool ExportToCSV(FString ThePath, FString Textbody, FString FileName, FString FolderName, bool OverwriteFile)
{
    ThePath += TEXT("/") + FolderName;
    FileName += TEXT(".csv");
    IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
 
    if (!PlatformFile.DirectoryExists(*ThePath))
    {
        PlatformFile.CreateDirectory(*ThePath);
    }
    FString AbsoluteFilePath = ThePath + TEXT("/") + FileName;
 
    if (OverwriteFile)
    {
        FFileHelper::SaveStringToFile(Textbody, *AbsoluteFilePath);
        return true;
    }
    FFileHelper::SaveStringToFile(Textbody, *AbsoluteFilePath, FFileHelper::EEncodingOptions::AutoDetect,
                                  &IFileManager::Get(),
                                  FILEWRITE_Append);
    return true;
 
    return false;
}
 
bool UPixoVRFunctionLibrary::GetIsOfflineModeEnabled()
{
    return GetDefault<UPixoCoreSettings>()->OfflineMode;
}
 
float UPixoVRFunctionLibrary::GetOfflineTime()
{
    return GetDefault<UPixoCoreSettings>()->OfflineTime;
}
 
FName UPixoVRFunctionLibrary::GetMapAfterLogin()
{
    return GetDefault<UPixoCoreSettings>()->MapAfterLogin;
}
 
FName UPixoVRFunctionLibrary::GetMapAfterIntro()
{
    return GetDefault<UPixoCoreSettings>()->MapAfterIntro;
}
 
FString UPixoVRFunctionLibrary::GetTestServerIP()
{
    return GetDefault<UPixoCoreSettings>()->TestServerIP;
}
 
void UPixoVRFunctionLibrary::SetLocalizationCulture(FString Culture)
{
    FInternationalization::Get().SetCurrentCulture(Culture);
}
 
FName UPixoVRFunctionLibrary::GetFullCultureName(FString Culture)
{
    if (Culture.Equals("en"))
            return "English";
    else if (Culture.Equals("de"))
            return "Deutch";
    else
        return "Undefined Language";
}
 
FString UPixoVRFunctionLibrary::GetMasterServiceIP()
{
    bool UseSSL = false;
    if (!FParse::Bool(FCommandLine::Get(), TEXT("-PIXOVR_LS_USE_SSL="), UseSSL))
    {
        if (GConfig && !GConfig->GetBool(TEXT("OnlineSubsystemPixoVR"), TEXT("UseSSL"), UseSSL, GEngineIni))
        {
        }
    }
 
    FString Protocol;
    if (UseSSL)
    {
        Protocol = TEXT("https://");
    }
    else
    {
        Protocol = TEXT("http://");
    }
 
    FString IP = "127.0.0.1";
    if (!FParse::Value(FCommandLine::Get(), TEXT("-PIXOVR_MS_IP="), IP))
    {
        if (GConfig && !GConfig->GetString(TEXT("OnlineSubsystemPixoVR"), TEXT("IP"), IP, GEngineIni))
        {
        }
    }
 
    int Port = 8000;
    if (!FParse::Value(FCommandLine::Get(), TEXT("-PIXOVR_MS_PORT="), Port))
    {
        if (GConfig && !GConfig->GetInt(TEXT("OnlineSubsystemPixoVR"), TEXT("Port"), Port, GEngineIni))
        {
        }
    }
 
    FString MasterServiceURL = Protocol + IP + ":" + FString::FromInt(Port);
 
    return MasterServiceURL;
}