Alphanium/CppSDK/SDK/OculusLibrary_functions.cpp

#pragma once

/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/

// Package: OculusLibrary

#include "Basic.hpp"

#include "OculusLibrary_classes.hpp"
#include "OculusLibrary_parameters.hpp"


#pragma pack(push, 0x4)
namespace SDK
{

// Function OculusLibrary.OculusFunctionLibrary.EnablePlayerCameraManagerFollowHmd
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    bFollowHmdOrientation                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bFollowHmdPosition                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::EnablePlayerCameraManagerFollowHmd(bool bFollowHmdOrientation, bool bFollowHmdPosition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "EnablePlayerCameraManagerFollowHmd");

	Params::OculusFunctionLibrary_EnablePlayerCameraManagerFollowHmd Parms{};

	Parms.bFollowHmdOrientation = bFollowHmdOrientation;
	Parms.bFollowHmdPosition = bFollowHmdPosition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function OculusLibrary.OculusFunctionLibrary.EnablePlayerControllerFollowHmd
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::EnablePlayerControllerFollowHmd(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "EnablePlayerControllerFollowHmd");

	Params::OculusFunctionLibrary_EnablePlayerControllerFollowHmd Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function OculusLibrary.OculusFunctionLibrary.GetBaseRotationAndBaseOffsetInMeters
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FRotator*                        OutRotation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         OutBaseOffsetInMeters                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::GetBaseRotationAndBaseOffsetInMeters(struct FRotator* OutRotation, struct FVector* OutBaseOffsetInMeters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "GetBaseRotationAndBaseOffsetInMeters");

	Params::OculusFunctionLibrary_GetBaseRotationAndBaseOffsetInMeters Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRotation != nullptr)
		*OutRotation = std::move(Parms.OutRotation);

	if (OutBaseOffsetInMeters != nullptr)
		*OutBaseOffsetInMeters = std::move(Parms.OutBaseOffsetInMeters);
}


// Function OculusLibrary.OculusFunctionLibrary.GetBaseRotationAndPositionOffset
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator*                        OutRot                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         OutPosOffset                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::GetBaseRotationAndPositionOffset(struct FRotator* OutRot, struct FVector* OutPosOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "GetBaseRotationAndPositionOffset");

	Params::OculusFunctionLibrary_GetBaseRotationAndPositionOffset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRot != nullptr)
		*OutRot = std::move(Parms.OutRot);

	if (OutPosOffset != nullptr)
		*OutPosOffset = std::move(Parms.OutPosOffset);
}


// Function OculusLibrary.OculusFunctionLibrary.GetPlayerCameraManagerFollowHmd
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// bool*                                   bFollowHmdOrientation                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   bFollowHmdPosition                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::GetPlayerCameraManagerFollowHmd(bool* bFollowHmdOrientation, bool* bFollowHmdPosition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "GetPlayerCameraManagerFollowHmd");

	Params::OculusFunctionLibrary_GetPlayerCameraManagerFollowHmd Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bFollowHmdOrientation != nullptr)
		*bFollowHmdOrientation = Parms.bFollowHmdOrientation;

	if (bFollowHmdPosition != nullptr)
		*bFollowHmdPosition = Parms.bFollowHmdPosition;
}


// Function OculusLibrary.OculusFunctionLibrary.GetPose
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FRotator*                        DeviceRotation                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         DevicePosition                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         NeckPosition                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bUseOrienationForPlayerCamera                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bUsePositionForPlayerCamera                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   PositionScale                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::GetPose(struct FRotator* DeviceRotation, struct FVector* DevicePosition, struct FVector* NeckPosition, bool bUseOrienationForPlayerCamera, bool bUsePositionForPlayerCamera, const struct FVector& PositionScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "GetPose");

	Params::OculusFunctionLibrary_GetPose Parms{};

	Parms.bUseOrienationForPlayerCamera = bUseOrienationForPlayerCamera;
	Parms.bUsePositionForPlayerCamera = bUsePositionForPlayerCamera;
	Parms.PositionScale = std::move(PositionScale);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (DeviceRotation != nullptr)
		*DeviceRotation = std::move(Parms.DeviceRotation);

	if (DevicePosition != nullptr)
		*DevicePosition = std::move(Parms.DevicePosition);

	if (NeckPosition != nullptr)
		*NeckPosition = std::move(Parms.NeckPosition);
}


// Function OculusLibrary.OculusFunctionLibrary.GetRawSensorData
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector*                         Accelerometer                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         Gyro                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         Magnetometer                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float*                                  Temperature                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  TimeInSeconds                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::GetRawSensorData(struct FVector* Accelerometer, struct FVector* Gyro, struct FVector* Magnetometer, float* Temperature, float* TimeInSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "GetRawSensorData");

	Params::OculusFunctionLibrary_GetRawSensorData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Accelerometer != nullptr)
		*Accelerometer = std::move(Parms.Accelerometer);

	if (Gyro != nullptr)
		*Gyro = std::move(Parms.Gyro);

	if (Magnetometer != nullptr)
		*Magnetometer = std::move(Parms.Magnetometer);

	if (Temperature != nullptr)
		*Temperature = Parms.Temperature;

	if (TimeInSeconds != nullptr)
		*TimeInSeconds = Parms.TimeInSeconds;
}


// Function OculusLibrary.OculusFunctionLibrary.GetUserProfile
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FHmdUserProfile*                 Profile                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UOculusFunctionLibrary::GetUserProfile(struct FHmdUserProfile* Profile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "GetUserProfile");

	Params::OculusFunctionLibrary_GetUserProfile Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Profile != nullptr)
		*Profile = std::move(Parms.Profile);

	return Parms.ReturnValue;
}


// Function OculusLibrary.OculusFunctionLibrary.IsPlayerControllerFollowHmdEnabled
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UOculusFunctionLibrary::IsPlayerControllerFollowHmdEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "IsPlayerControllerFollowHmdEnabled");

	Params::OculusFunctionLibrary_IsPlayerControllerFollowHmdEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function OculusLibrary.OculusFunctionLibrary.SetBaseRotationAndBaseOffsetInMeters
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   BaseOffsetInMeters                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EOrientPositionSelector                 Options                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::SetBaseRotationAndBaseOffsetInMeters(const struct FRotator& Rotation, const struct FVector& BaseOffsetInMeters, EOrientPositionSelector Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "SetBaseRotationAndBaseOffsetInMeters");

	Params::OculusFunctionLibrary_SetBaseRotationAndBaseOffsetInMeters Parms{};

	Parms.Rotation = std::move(Rotation);
	Parms.BaseOffsetInMeters = std::move(BaseOffsetInMeters);
	Parms.Options = Options;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function OculusLibrary.OculusFunctionLibrary.SetBaseRotationAndPositionOffset
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  BaseRot                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   PosOffset                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EOrientPositionSelector                 Options                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::SetBaseRotationAndPositionOffset(const struct FRotator& BaseRot, const struct FVector& PosOffset, EOrientPositionSelector Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "SetBaseRotationAndPositionOffset");

	Params::OculusFunctionLibrary_SetBaseRotationAndPositionOffset Parms{};

	Parms.BaseRot = std::move(BaseRot);
	Parms.PosOffset = std::move(PosOffset);
	Parms.Options = Options;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function OculusLibrary.OculusFunctionLibrary.SetPositionScale3D
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   PosScale3D                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UOculusFunctionLibrary::SetPositionScale3D(const struct FVector& PosScale3D)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OculusFunctionLibrary", "SetPositionScale3D");

	Params::OculusFunctionLibrary_SetPositionScale3D Parms{};

	Parms.PosScale3D = std::move(PosScale3D);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}

}

#pragma pack(pop)