#pragma once

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

// Package: b1

#include "Basic.hpp"

#include "b1_classes.hpp"
#include "b1_parameters.hpp"


namespace SDK
{

// Function b1.ActorDataContainer.AddDataObjInCS
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UActorDataContainer::AddDataObjInCS(class UObject* Obj)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorDataContainer", "AddDataObjInCS");

	Params::ActorDataContainer_AddDataObjInCS Parms{};

	Parms.Obj = Obj;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.ActorDataContainer.ClearDataObj
// (Final, Native, Protected, BlueprintCallable)

void UActorDataContainer::ClearDataObj()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorDataContainer", "ClearDataObj");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.ActorDataContainer.InitOnNewInCS
// (Event, Protected, BlueprintEvent)

void UActorDataContainer::InitOnNewInCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorDataContainer", "InitOnNewInCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.ActorDataContainer.LateECSBeginPlay
// (Event, Public, BlueprintEvent)

void UActorDataContainer::LateECSBeginPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorDataContainer", "LateECSBeginPlay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.ActorDataContainer.OnDestoryInCS
// (Event, Protected, BlueprintEvent)

void UActorDataContainer::OnDestoryInCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorDataContainer", "OnDestoryInCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.ActorDataContainer.PreECSBeginPlay
// (Event, Public, BlueprintEvent)

void UActorDataContainer::PreECSBeginPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorDataContainer", "PreECSBeginPlay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.ActorCompContainer.FillDataContainer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UActorDataContainer*              DataObj                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UActorCompContainer::FillDataContainer(class UActorDataContainer* DataObj)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorCompContainer", "FillDataContainer");

	Params::ActorCompContainer_FillDataContainer Parms{};

	Parms.DataObj = DataObj;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.ActorCompContainer.FillEventCollection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          DataObj                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UActorCompContainer::FillEventCollection(class UObject* DataObj)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorCompContainer", "FillEventCollection");

	Params::ActorCompContainer_FillEventCollection Parms{};

	Parms.DataObj = DataObj;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.ActorCompContainer.SetTeamID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UActorCompContainer::SetTeamID(int32 ID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ActorCompContainer", "SetTeamID");

	Params::ActorCompContainer_SetTeamID Parms{};

	Parms.ID = ID;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCrowdFollowingComponent.SetCrowdFollowingEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsObstacle                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCrowdFollowingComponent::SetCrowdFollowingEnabled(bool bEnabled, bool bIsObstacle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCrowdFollowingComponent", "SetCrowdFollowingEnabled");

	Params::BGUCrowdFollowingComponent_SetCrowdFollowingEnabled Parms{};

	Parms.bEnabled = bEnabled;
	Parms.bIsObstacle = bIsObstacle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCrowdFollowingComponent.SetCrowdFollowingParam
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   fSeparationWeight                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   fCollisionQueryRange                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   fPathOptimizationRange                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   iAvoidanceQualityLevel                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCrowdFollowingComponent::SetCrowdFollowingParam(float fSeparationWeight, float fCollisionQueryRange, float fPathOptimizationRange, int32 iAvoidanceQualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCrowdFollowingComponent", "SetCrowdFollowingParam");

	Params::BGUCrowdFollowingComponent_SetCrowdFollowingParam Parms{};

	Parms.fSeparationWeight = fSeparationWeight;
	Parms.fCollisionQueryRange = fCollisionQueryRange;
	Parms.fPathOptimizationRange = fPathOptimizationRange;
	Parms.iAvoidanceQualityLevel = iAvoidanceQualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.AnimNotifyFuncLibrary.ActorTryAnimNotifyDelayExecute
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           NotifyOwner                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAnimNotifyFuncLibrary::ActorTryAnimNotifyDelayExecute(class AActor* NotifyOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimNotifyFuncLibrary", "ActorTryAnimNotifyDelayExecute");

	Params::AnimNotifyFuncLibrary_ActorTryAnimNotifyDelayExecute Parms{};

	Parms.NotifyOwner = NotifyOwner;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyFuncLibrary.CanAnimNotifyDelayExecute
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           NotifyOwner                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAnimNotifyFuncLibrary::CanAnimNotifyDelayExecute(class AActor* NotifyOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimNotifyFuncLibrary", "CanAnimNotifyDelayExecute");

	Params::AnimNotifyFuncLibrary_CanAnimNotifyDelayExecute Parms{};

	Parms.NotifyOwner = NotifyOwner;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyFuncLibrary.DeleteAnimNotifyAndAnimNotifyState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EGsEnAnimN>&               NotifyTypeList                                         (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<EGsEnAnimNS>&              NotifyStateTypeList                                    (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UAnimNotifyFuncLibrary::DeleteAnimNotifyAndAnimNotifyState(class UAnimMontage* AnimMontage, const TArray<EGsEnAnimN>& NotifyTypeList, const TArray<EGsEnAnimNS>& NotifyStateTypeList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimNotifyFuncLibrary", "DeleteAnimNotifyAndAnimNotifyState");

	Params::AnimNotifyFuncLibrary_DeleteAnimNotifyAndAnimNotifyState Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.NotifyTypeList = std::move(NotifyTypeList);
	Parms.NotifyStateTypeList = std::move(NotifyStateTypeList);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.AnimNotifyFuncLibrary.GetAllAnimNotifySoftAsset
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAnimSequenceBase*                AnimBase                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<class UAnimNotify_GSBase*, struct FNotifySoftRefs>*outNotifyRefs                                          (Parm, OutParm, NativeAccessSpecifierPublic)
// TMap<class UAnimNotifyState_GSBase*, struct FNotifySoftRefs>*outNotifyStateRefs                                     (Parm, OutParm, NativeAccessSpecifierPublic)

void UAnimNotifyFuncLibrary::GetAllAnimNotifySoftAsset(class UAnimSequenceBase* AnimBase, TMap<class UAnimNotify_GSBase*, struct FNotifySoftRefs>* outNotifyRefs, TMap<class UAnimNotifyState_GSBase*, struct FNotifySoftRefs>* outNotifyStateRefs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimNotifyFuncLibrary", "GetAllAnimNotifySoftAsset");

	Params::AnimNotifyFuncLibrary_GetAllAnimNotifySoftAsset Parms{};

	Parms.AnimBase = AnimBase;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.AnimNotifyFuncLibrary.PrepareAnimationsNotifySoftAsset
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UAnimSequenceBase*>& AnimBases                                              (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// TMap<class UAnimNotify_GSBase*, struct FNotifySoftRefs>*outNotifyRefs                                          (Parm, OutParm, NativeAccessSpecifierPublic)
// TMap<class UAnimNotifyState_GSBase*, struct FNotifySoftRefs>*outNotifyStateRefs                                     (Parm, OutParm, NativeAccessSpecifierPublic)

void UAnimNotifyFuncLibrary::PrepareAnimationsNotifySoftAsset(const TArray<class UAnimSequenceBase*>& AnimBases, TMap<class UAnimNotify_GSBase*, struct FNotifySoftRefs>* outNotifyRefs, TMap<class UAnimNotifyState_GSBase*, struct FNotifySoftRefs>* outNotifyStateRefs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimNotifyFuncLibrary", "PrepareAnimationsNotifySoftAsset");

	Params::AnimNotifyFuncLibrary_PrepareAnimationsNotifySoftAsset Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.AnimNotifyFuncLibrary.PrepareAnimNotifySoftAsset
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAnimSequenceBase*                AnimBase                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<class UAnimNotify_GSBase*, struct FNotifySoftRefs>*outNotifyRefs                                          (Parm, OutParm, NativeAccessSpecifierPublic)
// TMap<class UAnimNotifyState_GSBase*, struct FNotifySoftRefs>*outNotifyStateRefs                                     (Parm, OutParm, NativeAccessSpecifierPublic)

void UAnimNotifyFuncLibrary::PrepareAnimNotifySoftAsset(class UAnimSequenceBase* AnimBase, TMap<class UAnimNotify_GSBase*, struct FNotifySoftRefs>* outNotifyRefs, TMap<class UAnimNotifyState_GSBase*, struct FNotifySoftRefs>* outNotifyStateRefs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimNotifyFuncLibrary", "PrepareAnimNotifySoftAsset");

	Params::AnimNotifyFuncLibrary_PrepareAnimNotifySoftAsset Parms{};

	Parms.AnimBase = AnimBase;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUDataComp.InitWithAIController
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABGUAIController*                 AIController                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUDataComp::InitWithAIController(class ABGUAIController* AIController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDataComp", "InitWithAIController");

	Params::BGUDataComp_InitWithAIController Parms{};

	Parms.AIController = AIController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUDataComp.InitWithCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABGUCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUDataComp::InitWithCharacter(class ABGUCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDataComp", "InitWithCharacter");

	Params::BGUDataComp_InitWithCharacter Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.AnimNotifyState_GSBase.AddPreloadedAsset
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::AddPreloadedAsset(class UObject* Obj) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "AddPreloadedAsset");

	Params::AnimNotifyState_GSBase_AddPreloadedAsset Parms{};

	Parms.Obj = Obj;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.AnimNotifyState_GSBase.GetAnimNSType
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// EGsEnAnimNS                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGsEnAnimNS UAnimNotifyState_GSBase::GetAnimNSType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GetAnimNSType");

	Params::AnimNotifyState_GSBase_GetAnimNSType Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GetJumpableSectionPrefix
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UAnimNotifyState_GSBase::GetJumpableSectionPrefix() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GetJumpableSectionPrefix");

	Params::AnimNotifyState_GSBase_GetJumpableSectionPrefix Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GetModifySpeedRate
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAnimNotifyState_GSBase::GetModifySpeedRate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GetModifySpeedRate");

	Params::AnimNotifyState_GSBase_GetModifySpeedRate Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GetPreloadedAssets
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// TArray<class UObject*>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UObject*> UAnimNotifyState_GSBase::GetPreloadedAssets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GetPreloadedAssets");

	Params::AnimNotifyState_GSBase_GetPreloadedAssets Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GetSoftReferences
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// TArray<struct FSoftObjectPath>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FSoftObjectPath> UAnimNotifyState_GSBase::GetSoftReferences() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GetSoftReferences");

	Params::AnimNotifyState_GSBase_GetSoftReferences Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSAllowCrossSection
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAnimNotifyState_GSBase::GSAllowCrossSection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSAllowCrossSection");

	Params::AnimNotifyState_GSBase_GSAllowCrossSection Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSNotifyBegin_Delay
// (Final, Native, Public, HasOutParams, BlueprintCallable, Const)
// Parameters:
// struct FUStGSNotifyParam*               NotifyParam                                            (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   TotalDuration                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSNotifyBegin_Delay(struct FUStGSNotifyParam* NotifyParam, float TotalDuration) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyBegin_Delay");

	Params::AnimNotifyState_GSBase_GSNotifyBegin_Delay Parms{};

	Parms.TotalDuration = TotalDuration;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function b1.AnimNotifyState_GSBase.GSNotifyBeginCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   TotalDuration                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSNotifyBeginCS(const struct FUStGSNotifyParam& NotifyParam, float TotalDuration) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyBeginCS");

	Params::AnimNotifyState_GSBase_GSNotifyBeginCS Parms{};

	Parms.NotifyParam = std::move(NotifyParam);
	Parms.TotalDuration = TotalDuration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.AnimNotifyState_GSBase.GSNotifyDebugPostBeginCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotifyState_GSBase::GSNotifyDebugPostBeginCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyDebugPostBeginCS");

	Params::AnimNotifyState_GSBase_GSNotifyDebugPostBeginCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSNotifyDebugPostEndCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotifyState_GSBase::GSNotifyDebugPostEndCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyDebugPostEndCS");

	Params::AnimNotifyState_GSBase_GSNotifyDebugPostEndCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSNotifyDebugPostTickCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotifyState_GSBase::GSNotifyDebugPostTickCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyDebugPostTickCS");

	Params::AnimNotifyState_GSBase_GSNotifyDebugPostTickCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSNotifyDebugPreBeginCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotifyState_GSBase::GSNotifyDebugPreBeginCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyDebugPreBeginCS");

	Params::AnimNotifyState_GSBase_GSNotifyDebugPreBeginCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSNotifyDebugPreEndCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotifyState_GSBase::GSNotifyDebugPreEndCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyDebugPreEndCS");

	Params::AnimNotifyState_GSBase_GSNotifyDebugPreEndCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSNotifyDebugPreTickCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotifyState_GSBase::GSNotifyDebugPreTickCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyDebugPreTickCS");

	Params::AnimNotifyState_GSBase_GSNotifyDebugPreTickCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSBase.GSNotifyEnd_Delay
// (Final, Native, Public, HasOutParams, BlueprintCallable, Const)
// Parameters:
// struct FUStGSNotifyParam*               NotifyParam                                            (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSNotifyEnd_Delay(struct FUStGSNotifyParam* NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyEnd_Delay");

	Params::AnimNotifyState_GSBase_GSNotifyEnd_Delay Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function b1.AnimNotifyState_GSBase.GSNotifyEndCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSNotifyEndCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyEndCS");

	Params::AnimNotifyState_GSBase_GSNotifyEndCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.AnimNotifyState_GSBase.GSNotifyTick_Delay
// (Final, Native, Public, HasOutParams, BlueprintCallable, Const)
// Parameters:
// struct FUStGSNotifyParam*               NotifyParam                                            (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   FrameDeltaTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSNotifyTick_Delay(struct FUStGSNotifyParam* NotifyParam, float FrameDeltaTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyTick_Delay");

	Params::AnimNotifyState_GSBase_GSNotifyTick_Delay Parms{};

	Parms.FrameDeltaTime = FrameDeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function b1.AnimNotifyState_GSBase.GSNotifyTickCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   FrameDeltaTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSNotifyTickCS(const struct FUStGSNotifyParam& NotifyParam, float FrameDeltaTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSNotifyTickCS");

	Params::AnimNotifyState_GSBase_GSNotifyTickCS Parms{};

	Parms.NotifyParam = std::move(NotifyParam);
	Parms.FrameDeltaTime = FrameDeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.AnimNotifyState_GSBase.GSOnSectionManuallyChanged
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class ABGUCharacter*                    OwnerChar                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RemainingDuration                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSOnSectionManuallyChanged(class ABGUCharacter* OwnerChar, float RemainingDuration) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSOnSectionManuallyChanged");

	Params::AnimNotifyState_GSBase_GSOnSectionManuallyChanged Parms{};

	Parms.OwnerChar = OwnerChar;
	Parms.RemainingDuration = RemainingDuration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.AnimNotifyState_GSBase.GSValidateInputCS
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::GSValidateInputCS(class AActor* Actor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "GSValidateInputCS");

	Params::AnimNotifyState_GSBase_GSValidateInputCS Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.AnimNotifyState_GSBase.UpdateDataOnNotifyStateReplace
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// const class UAnimNotifyState*           NewNotifyState                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotifyState_GSBase::UpdateDataOnNotifyStateReplace(const class UAnimNotifyState* NewNotifyState) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSBase", "UpdateDataOnNotifyStateReplace");

	Params::AnimNotifyState_GSBase_UpdateDataOnNotifyStateReplace Parms{};

	Parms.NewNotifyState = NewNotifyState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.EnvironmentSurfaceEffectMgr.GetEnvironmentSurfaceVolumeByLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ABGWEnvironmentSurfaceVolume*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABGWEnvironmentSurfaceVolume* AEnvironmentSurfaceEffectMgr::GetEnvironmentSurfaceVolumeByLocation(const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentSurfaceEffectMgr", "GetEnvironmentSurfaceVolumeByLocation");

	Params::EnvironmentSurfaceEffectMgr_GetEnvironmentSurfaceVolumeByLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.EnvironmentSurfaceEffectMgr.RegisterVolume
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSoftObjectPtr<class ABGWEnvironmentSurfaceVolume>&InVolume                                               (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEnvironmentSurfaceEffectMgr::RegisterVolume(const TSoftObjectPtr<class ABGWEnvironmentSurfaceVolume>& InVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentSurfaceEffectMgr", "RegisterVolume");

	Params::EnvironmentSurfaceEffectMgr_RegisterVolume Parms{};

	Parms.InVolume = InVolume;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.EnvironmentSurfaceEffectMgr.UnregisterVolume
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSoftObjectPtr<class ABGWEnvironmentSurfaceVolume>&InVolume                                               (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsDisableVolume                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEnvironmentSurfaceEffectMgr::UnregisterVolume(const TSoftObjectPtr<class ABGWEnvironmentSurfaceVolume>& InVolume, bool IsDisableVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentSurfaceEffectMgr", "UnregisterVolume");

	Params::EnvironmentSurfaceEffectMgr_UnregisterVolume Parms{};

	Parms.InVolume = InVolume;
	Parms.IsDisableVolume = IsDisableVolume;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUDebugCircleComponent.SetCircleRadius
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InCircleRadius                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUDebugCircleComponent::SetCircleRadius(float InCircleRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugCircleComponent", "SetCircleRadius");

	Params::BGUDebugCircleComponent_SetCircleRadius Parms{};

	Parms.InCircleRadius = InCircleRadius;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUDebugCircleComponent.GetScaledCircleRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUDebugCircleComponent::GetScaledCircleRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugCircleComponent", "GetScaledCircleRadius");

	Params::BGUDebugCircleComponent_GetScaledCircleRadius Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUDebugCircleComponent.GetShapeScale
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUDebugCircleComponent::GetShapeScale() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugCircleComponent", "GetShapeScale");

	Params::BGUDebugCircleComponent_GetShapeScale Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUDebugCircleComponent.GetUnscaledCircleRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUDebugCircleComponent::GetUnscaledCircleRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugCircleComponent", "GetUnscaledCircleRadius");

	Params::BGUDebugCircleComponent_GetUnscaledCircleRadius Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUDebugSectorComponent.SetSectorMaxAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InMaxAngle                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUDebugSectorComponent::SetSectorMaxAngle(float InMaxAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugSectorComponent", "SetSectorMaxAngle");

	Params::BGUDebugSectorComponent_SetSectorMaxAngle Parms{};

	Parms.InMaxAngle = InMaxAngle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUDebugSectorComponent.SetSectorMinAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InMinAngle                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUDebugSectorComponent::SetSectorMinAngle(float InMinAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugSectorComponent", "SetSectorMinAngle");

	Params::BGUDebugSectorComponent_SetSectorMinAngle Parms{};

	Parms.InMinAngle = InMinAngle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUDebugSectorComponent.SetSectorRadius
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InSectorRadius                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUDebugSectorComponent::SetSectorRadius(float InSectorRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugSectorComponent", "SetSectorRadius");

	Params::BGUDebugSectorComponent_SetSectorRadius Parms{};

	Parms.InSectorRadius = InSectorRadius;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUDebugSectorComponent.GetScaledSectorRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUDebugSectorComponent::GetScaledSectorRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugSectorComponent", "GetScaledSectorRadius");

	Params::BGUDebugSectorComponent_GetScaledSectorRadius Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUDebugSectorComponent.GetShapeScale
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUDebugSectorComponent::GetShapeScale() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugSectorComponent", "GetShapeScale");

	Params::BGUDebugSectorComponent_GetShapeScale Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUDebugSectorComponent.GetUnscaledSectorRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUDebugSectorComponent::GetUnscaledSectorRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUDebugSectorComponent", "GetUnscaledSectorRadius");

	Params::BGUDebugSectorComponent_GetUnscaledSectorRadius Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUEditorTickableActor.GetViewportCameraLocation
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ABGUEditorTickableActor::GetViewportCameraLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUEditorTickableActor", "GetViewportCameraLocation");

	Params::BGUEditorTickableActor_GetViewportCameraLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUEQSObject.EQSObjRun
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UEnvQuery*                  EnvQueryObj                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBGURunEQSObjReason                     Reason                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGSEQSExParam&             _ExParam                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUEQSObject::EQSObjRun(const class UEnvQuery* EnvQueryObj, class AActor* Querier, EBGURunEQSObjReason Reason, const struct FGSEQSExParam& _ExParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUEQSObject", "EQSObjRun");

	Params::BGUEQSObject_EQSObjRun Parms{};

	Parms.EnvQueryObj = EnvQueryObj;
	Parms.Querier = Querier;
	Parms.Reason = Reason;
	Parms._ExParam = std::move(_ExParam);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUEQSObject.EQSObjRunInstant
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UEnvQuery*                  EnvQueryObj                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FVector>*                 Locations                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<float>*                          Scores                                                 (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBGUEQSObject::EQSObjRunInstant(const class UEnvQuery* EnvQueryObj, class AActor* Querier, TArray<struct FVector>* Locations, TArray<float>* Scores)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUEQSObject", "EQSObjRunInstant");

	Params::BGUEQSObject_EQSObjRunInstant Parms{};

	Parms.EnvQueryObj = EnvQueryObj;
	Parms.Querier = Querier;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUEQSObject.EQSObjRunInstantWithCustomParams
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UEnvQuery*                  EnvQueryObj                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FGSEnvNamedValue>&  NamedParams                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FVector>*                 Locations                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<float>*                          Scores                                                 (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBGUEQSObject::EQSObjRunInstantWithCustomParams(const class UEnvQuery* EnvQueryObj, class AActor* Querier, const TArray<struct FGSEnvNamedValue>& NamedParams, TArray<struct FVector>* Locations, TArray<float>* Scores)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUEQSObject", "EQSObjRunInstantWithCustomParams");

	Params::BGUEQSObject_EQSObjRunInstantWithCustomParams Parms{};

	Parms.EnvQueryObj = EnvQueryObj;
	Parms.Querier = Querier;
	Parms.NamedParams = std::move(NamedParams);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUEQSObject.EQSObjRunWithCustomParams
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UEnvQuery*                  EnvQueryObj                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBGURunEQSObjReason                     Reason                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FGSEnvNamedValue>&  NamedParams                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUEQSObject::EQSObjRunWithCustomParams(const class UEnvQuery* EnvQueryObj, class AActor* Querier, EBGURunEQSObjReason Reason, const TArray<struct FGSEnvNamedValue>& NamedParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUEQSObject", "EQSObjRunWithCustomParams");

	Params::BGUEQSObject_EQSObjRunWithCustomParams Parms{};

	Parms.EnvQueryObj = EnvQueryObj;
	Parms.Querier = Querier;
	Parms.Reason = Reason;
	Parms.NamedParams = std::move(NamedParams);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUEQSObject.EQSRun
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    EQSPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBGURunEQSObjReason                     Reason                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGSEQSExParam&             _ExParam                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUEQSObject::EQSRun(const class FString& EQSPath, class AActor* Querier, EBGURunEQSObjReason Reason, const struct FGSEQSExParam& _ExParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUEQSObject", "EQSRun");

	Params::BGUEQSObject_EQSRun Parms{};

	Parms.EQSPath = std::move(EQSPath);
	Parms.Querier = Querier;
	Parms.Reason = Reason;
	Parms._ExParam = std::move(_ExParam);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFluid2DComponent.GetPressureDivergenceTexture
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// class UTextureRenderTarget2D*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTextureRenderTarget2D* UBGUFluid2DComponent::GetPressureDivergenceTexture()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFluid2DComponent", "GetPressureDivergenceTexture");

	Params::BGUFluid2DComponent_GetPressureDivergenceTexture Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFluid2DComponent.GetVeloDensityTexture
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// class UTextureRenderTarget2D*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTextureRenderTarget2D* UBGUFluid2DComponent::GetVeloDensityTexture()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFluid2DComponent", "GetVeloDensityTexture");

	Params::BGUFluid2DComponent_GetVeloDensityTexture Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGU_AIMover.AbortMove
// (Final, Native, Public, BlueprintCallable)

void UBGU_AIMover::AbortMove()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "AbortMove");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGU_AIMover.GetRequestID
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGU_AIMover::GetRequestID()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "GetRequestID");

	Params::BGU_AIMover_GetRequestID Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGU_AIMover.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AController*                      OwnerAICtrl                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGU_AIMover::Init(class AController* OwnerAICtrl)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "Init");

	Params::BGU_AIMover_Init Parms{};

	Parms.OwnerAICtrl = OwnerAICtrl;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGU_AIMover.IsOutOfRange
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGU_AIMover::IsOutOfRange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "IsOutOfRange");

	Params::BGU_AIMover_IsOutOfRange Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGU_AIMover.IsRequestValid
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGU_AIMover::IsRequestValid()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "IsRequestValid");

	Params::BGU_AIMover_IsRequestValid Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGU_AIMover.MoveTo
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FBGU_AIMoverRequest&       request                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UBGU_AIMover::MoveTo(const struct FBGU_AIMoverRequest& request)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "MoveTo");

	Params::BGU_AIMover_MoveTo Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGU_AIMover.ResetRequest
// (Final, Native, Public, BlueprintCallable)

void UBGU_AIMover::ResetRequest()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "ResetRequest");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGU_AIMover.GetMoveStatus
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPathFollowingStatus                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPathFollowingStatus UBGU_AIMover::GetMoveStatus() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "GetMoveStatus");

	Params::BGU_AIMover_GetMoveStatus Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGU_AIMover.GetPathFollowingComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPathFollowingComponent*          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPathFollowingComponent* UBGU_AIMover::GetPathFollowingComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGU_AIMover", "GetPathFollowingComponent");

	Params::BGU_AIMover_GetPathFollowingComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibData.BGUGetTagEnum
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8*                                  Out                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUGetTagEnum(class AActor* Unit, const struct FGameplayTag& Tag, bool* IsValid, uint8* Out)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagEnum");

	Params::BGUFuncLibData_BGUGetTagEnum Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFuncLibData.BGUGetTagFloat
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Out                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUGetTagFloat(class AActor* Unit, const struct FGameplayTag& Tag, bool* IsValid, float* Out)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagFloat");

	Params::BGUFuncLibData_BGUGetTagFloat Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFuncLibData.BGUGetTagFloatByName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      TagName                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Out                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUGetTagFloatByName(class AActor* Unit, const class FName& TagName, bool* IsValid, float* Out)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagFloatByName");

	Params::BGUFuncLibData_BGUGetTagFloatByName Parms{};

	Parms.Unit = Unit;
	Parms.TagName = TagName;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFuncLibData.BGUGetTagInt
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Out                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUGetTagInt(class AActor* Unit, const struct FGameplayTag& Tag, bool* IsValid, int32* Out)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagInt");

	Params::BGUFuncLibData_BGUGetTagInt Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFuncLibData.BGUGetTagIntByName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      TagName                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Out                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUGetTagIntByName(class AActor* Unit, const class FName& TagName, bool* IsValid, int32* Out)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagIntByName");

	Params::BGUFuncLibData_BGUGetTagIntByName Parms{};

	Parms.Unit = Unit;
	Parms.TagName = TagName;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFuncLibData.BGUGetTagName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName*                            Out                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUGetTagName(class AActor* Unit, const struct FGameplayTag& Tag, bool* IsValid, class FName* Out)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagName");

	Params::BGUFuncLibData_BGUGetTagName Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFuncLibData.BGUGetTagObject
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UBGUFuncLibData::BGUGetTagObject(class AActor* Unit, const struct FGameplayTag& Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagObject");

	Params::BGUFuncLibData_BGUGetTagObject Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibData.BGUGetTagVector
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         Out                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUGetTagVector(class AActor* Unit, const struct FGameplayTag& Tag, bool* IsValid, struct FVector* Out)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUGetTagVector");

	Params::BGUFuncLibData_BGUGetTagVector Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFuncLibData.BGUSetTagEnum
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   Val                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagEnum(class AActor* Unit, const struct FGameplayTag& Tag, uint8 Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagEnum");

	Params::BGUFuncLibData_BGUSetTagEnum Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);
	Parms.Val = Val;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagFloat
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Val                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagFloat(class AActor* Unit, const struct FGameplayTag& Tag, float Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagFloat");

	Params::BGUFuncLibData_BGUSetTagFloat Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);
	Parms.Val = Val;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagFloatByName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      TagName                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Val                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagFloatByName(class AActor* Unit, const class FName& TagName, float Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagFloatByName");

	Params::BGUFuncLibData_BGUSetTagFloatByName Parms{};

	Parms.Unit = Unit;
	Parms.TagName = TagName;
	Parms.Val = Val;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagInt
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Val                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagInt(class AActor* Unit, const struct FGameplayTag& Tag, int32 Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagInt");

	Params::BGUFuncLibData_BGUSetTagInt Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);
	Parms.Val = Val;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagIntByName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      TagName                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Val                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagIntByName(class AActor* Unit, const class FName& TagName, float Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagIntByName");

	Params::BGUFuncLibData_BGUSetTagIntByName Parms{};

	Parms.Unit = Unit;
	Parms.TagName = TagName;
	Parms.Val = Val;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Val                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagName(class AActor* Unit, const struct FGameplayTag& Tag, const class FName& Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagName");

	Params::BGUFuncLibData_BGUSetTagName Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);
	Parms.Val = Val;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagNameWithGameplayTag
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Val                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagNameWithGameplayTag(class AActor* Unit, const struct FGameplayTag& Tag, const struct FGameplayTag& Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagNameWithGameplayTag");

	Params::BGUFuncLibData_BGUSetTagNameWithGameplayTag Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);
	Parms.Val = std::move(Val);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagObject
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Val                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagObject(class AActor* Unit, const struct FGameplayTag& Tag, class UObject* Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagObject");

	Params::BGUFuncLibData_BGUSetTagObject Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);
	Parms.Val = Val;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibData.BGUSetTagVector
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Val                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibData::BGUSetTagVector(class AActor* Unit, const struct FGameplayTag& Tag, const struct FVector& Val)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibData", "BGUSetTagVector");

	Params::BGUFuncLibData_BGUSetTagVector Parms{};

	Parms.Unit = Unit;
	Parms.Tag = std::move(Tag);
	Parms.Val = std::move(Val);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQGBase_ProjectedPoint.AddGeneratedActor
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class AActor*                           GeneratedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQGBase_ProjectedPoint::AddGeneratedActor(class AActor* GeneratedActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQGBase_ProjectedPoint", "AddGeneratedActor");

	Params::GSEQGBase_ProjectedPoint_AddGeneratedActor Parms{};

	Parms.GeneratedActor = GeneratedActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQGBase_ProjectedPoint.AddGeneratedVector
// (Final, Native, Public, HasDefaults, BlueprintCallable, Const)
// Parameters:
// const struct FVector&                   GeneratedVector                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQGBase_ProjectedPoint::AddGeneratedVector(const struct FVector& GeneratedVector) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQGBase_ProjectedPoint", "AddGeneratedVector");

	Params::GSEQGBase_ProjectedPoint_AddGeneratedVector Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQGBase_ProjectedPoint.DoItemGenerationCS
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const TArray<struct FVector>&           ContextLocations                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UGSEQGBase_ProjectedPoint::DoItemGenerationCS(const TArray<struct FVector>& ContextLocations) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQGBase_ProjectedPoint", "DoItemGenerationCS");

	Params::GSEQGBase_ProjectedPoint_DoItemGenerationCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.GSEQGBase_ProjectedPoint.GetQuerier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UGSEQGBase_ProjectedPoint::GetQuerier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQGBase_ProjectedPoint", "GetQuerier");

	Params::GSEQGBase_ProjectedPoint_GetQuerier Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSEQGBase_ProjectedPoint.ProjectAndFilterNavPointsInCS
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FVector>&           Points                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FVector>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FVector> UGSEQGBase_ProjectedPoint::ProjectAndFilterNavPointsInCS(const TArray<struct FVector>& Points) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQGBase_ProjectedPoint", "ProjectAndFilterNavPointsInCS");

	Params::GSEQGBase_ProjectedPoint_ProjectAndFilterNavPointsInCS Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSEQGBase_ProjectedPoint.RunNavRaycastsInCS
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FVector>&           Points                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   SourcePt                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FVector>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FVector> UGSEQGBase_ProjectedPoint::RunNavRaycastsInCS(const TArray<struct FVector>& Points, const struct FVector& SourcePt) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQGBase_ProjectedPoint", "RunNavRaycastsInCS");

	Params::GSEQGBase_ProjectedPoint_RunNavRaycastsInCS Parms{};

	Parms.Points = std::move(Points);
	Parms.SourcePt = std::move(SourcePt);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibMove.BGUMovementForceSaveBaseLocation
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UCharacterMovementComponent*      MoveComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibMove::BGUMovementForceSaveBaseLocation(class UCharacterMovementComponent* MoveComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibMove", "BGUMovementForceSaveBaseLocation");

	Params::BGUFuncLibMove_BGUMovementForceSaveBaseLocation Parms{};

	Parms.MoveComp = MoveComp;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibAI.BGUAICaculateTargetAngle
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Target                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           MySelf                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFuncLibAI::BGUAICaculateTargetAngle(class AActor* Target, class AActor* MySelf)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibAI", "BGUAICaculateTargetAngle");

	Params::BGUFuncLibAI_BGUAICaculateTargetAngle Parms{};

	Parms.Target = Target;
	Parms.MySelf = MySelf;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibAI.BGUIsAIRequestActive
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RequestID                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibAI::BGUIsAIRequestActive(class AActor* Unit, int32 RequestID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibAI", "BGUIsAIRequestActive");

	Params::BGUFuncLibAI_BGUIsAIRequestActive Parms{};

	Parms.Unit = Unit;
	Parms.RequestID = RequestID;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibAI.BGURequestAITurnTo
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFuncLibAI::BGURequestAITurnTo(class AActor* Unit, const struct FVector& position)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibAI", "BGURequestAITurnTo");

	Params::BGUFuncLibAI_BGURequestAITurnTo Parms{};

	Parms.Unit = Unit;
	Parms.position = std::move(position);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotifyState_GSTrailWithArray.OverridePSTemplate
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class USkeletalMeshComponent*           MeshComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UParticleSystem*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UParticleSystem* UAnimNotifyState_GSTrailWithArray::OverridePSTemplate(class USkeletalMeshComponent* MeshComp, class UAnimSequenceBase* Animation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotifyState_GSTrailWithArray", "OverridePSTemplate");

	Params::AnimNotifyState_GSTrailWithArray_OverridePSTemplate Parms{};

	Parms.MeshComp = MeshComp;
	Parms.Animation = Animation;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.BGUCalcMontageNeedModifyTotalTime
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FromAMInstanceID                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFuncLibSkill::BGUCalcMontageNeedModifyTotalTime(class ACharacter* Unit, int32 FromAMInstanceID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "BGUCalcMontageNeedModifyTotalTime");

	Params::BGUFuncLibSkill_BGUCalcMontageNeedModifyTotalTime Parms{};

	Parms.Unit = Unit;
	Parms.FromAMInstanceID = FromAMInstanceID;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.BGUCalcMontageSpecificRangeTime
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FromAMInstanceID                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LeftTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RightTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     CurMontage                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFuncLibSkill::BGUCalcMontageSpecificRangeTime(class AActor* Unit, int32 FromAMInstanceID, float LeftTime, float RightTime, class UAnimMontage* CurMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "BGUCalcMontageSpecificRangeTime");

	Params::BGUFuncLibSkill_BGUCalcMontageSpecificRangeTime Parms{};

	Parms.Unit = Unit;
	Parms.FromAMInstanceID = FromAMInstanceID;
	Parms.LeftTime = LeftTime;
	Parms.RightTime = RightTime;
	Parms.CurMontage = CurMontage;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.BGUCalcNotifyNeedModifyTotalTime
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimNotifyState*           NotifyEvent                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FromAMInstanceID                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CurNSLeftTime                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CurNSRightTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFuncLibSkill::BGUCalcNotifyNeedModifyTotalTime(class ACharacter* Unit, const class UAnimNotifyState* NotifyEvent, int32 FromAMInstanceID, float CurNSLeftTime, float CurNSRightTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "BGUCalcNotifyNeedModifyTotalTime");

	Params::BGUFuncLibSkill_BGUCalcNotifyNeedModifyTotalTime Parms{};

	Parms.Unit = Unit;
	Parms.NotifyEvent = NotifyEvent;
	Parms.FromAMInstanceID = FromAMInstanceID;
	Parms.CurNSLeftTime = CurNSLeftTime;
	Parms.CurNSRightTime = CurNSRightTime;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.BGUGetActiveInstanceIDForMontage
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAnimInstance*                    AnimInstance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFuncLibSkill::BGUGetActiveInstanceIDForMontage(class UAnimInstance* AnimInstance, const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "BGUGetActiveInstanceIDForMontage");

	Params::BGUFuncLibSkill_BGUGetActiveInstanceIDForMontage Parms{};

	Parms.AnimInstance = AnimInstance;
	Parms.Montage = Montage;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.BGUGetMontageHasRootMotion
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSkill::BGUGetMontageHasRootMotion(const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "BGUGetMontageHasRootMotion");

	Params::BGUFuncLibSkill_BGUGetMontageHasRootMotion Parms{};

	Parms.Montage = Montage;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.BGUGetMontageNotifies
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FAnimNotifyEvent>*        OutActiveNotifies                                      (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UBGUFuncLibSkill::BGUGetMontageNotifies(const class UAnimMontage* Montage, TArray<struct FAnimNotifyEvent>* OutActiveNotifies)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "BGUGetMontageNotifies");

	Params::BGUFuncLibSkill_BGUGetMontageNotifies Parms{};

	Parms.Montage = Montage;

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

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

	Func->FunctionFlags = Flgs;

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


// Function b1.BGUFuncLibSkill.BGUGetMotionDirFromSkill
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// int32                                   SkillID                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UBGUFuncLibSkill::BGUGetMotionDirFromSkill(int32 SkillID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "BGUGetMotionDirFromSkill");

	Params::BGUFuncLibSkill_BGUGetMotionDirFromSkill Parms{};

	Parms.SkillID = SkillID;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.MontageInstanceBindUFunctionToMontageBlendOutDel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAnimInstance*                    AnimInstance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Object                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       FunctionName                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSkill::MontageInstanceBindUFunctionToMontageBlendOutDel(class UAnimInstance* AnimInstance, const class UAnimMontage* Montage, class UObject* Object, const class FName FunctionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "MontageInstanceBindUFunctionToMontageBlendOutDel");

	Params::BGUFuncLibSkill_MontageInstanceBindUFunctionToMontageBlendOutDel Parms{};

	Parms.AnimInstance = AnimInstance;
	Parms.Montage = Montage;
	Parms.Object = Object;
	Parms.FunctionName = FunctionName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.MontageInstanceBindUFunctionToMontegeEndDel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAnimInstance*                    AnimInstance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Object                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       FunctionName                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSkill::MontageInstanceBindUFunctionToMontegeEndDel(class UAnimInstance* AnimInstance, const class UAnimMontage* Montage, class UObject* Object, const class FName FunctionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "MontageInstanceBindUFunctionToMontegeEndDel");

	Params::BGUFuncLibSkill_MontageInstanceBindUFunctionToMontegeEndDel Parms{};

	Parms.AnimInstance = AnimInstance;
	Parms.Montage = Montage;
	Parms.Object = Object;
	Parms.FunctionName = FunctionName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.MontageInstanceUnBindUFunctionToMontageBlendOutDel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAnimInstance*                    AnimInstance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSkill::MontageInstanceUnBindUFunctionToMontageBlendOutDel(class UAnimInstance* AnimInstance, const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "MontageInstanceUnBindUFunctionToMontageBlendOutDel");

	Params::BGUFuncLibSkill_MontageInstanceUnBindUFunctionToMontageBlendOutDel Parms{};

	Parms.AnimInstance = AnimInstance;
	Parms.Montage = Montage;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSkill.MontageInstanceUnBindUFunctionToMontegeEndDel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAnimInstance*                    AnimInstance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSkill::MontageInstanceUnBindUFunctionToMontegeEndDel(class UAnimInstance* AnimInstance, const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSkill", "MontageInstanceUnBindUFunctionToMontegeEndDel");

	Params::BGUFuncLibSkill_MontageInstanceUnBindUFunctionToMontegeEndDel Parms{};

	Parms.AnimInstance = AnimInstance;
	Parms.Montage = Montage;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.AddPreloadedAsset
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotify_GSBase::AddPreloadedAsset(class UObject* Obj) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "AddPreloadedAsset");

	Params::AnimNotify_GSBase_AddPreloadedAsset Parms{};

	Parms.Obj = Obj;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.AnimNotify_GSBase.bIsNativeBranchingPointCS
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAnimNotify_GSBase::bIsNativeBranchingPointCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "bIsNativeBranchingPointCS");

	Params::AnimNotify_GSBase_bIsNativeBranchingPointCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.GetAnimNType
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// EGsEnAnimN                              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGsEnAnimN UAnimNotify_GSBase::GetAnimNType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GetAnimNType");

	Params::AnimNotify_GSBase_GetAnimNType Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.GetJumpableSectionPrefix
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UAnimNotify_GSBase::GetJumpableSectionPrefix() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GetJumpableSectionPrefix");

	Params::AnimNotify_GSBase_GetJumpableSectionPrefix Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.GetPreloadedAssets
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// TArray<class UObject*>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UObject*> UAnimNotify_GSBase::GetPreloadedAssets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GetPreloadedAssets");

	Params::AnimNotify_GSBase_GetPreloadedAssets Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.GetSoftReferences
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// TArray<struct FSoftObjectPath>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FSoftObjectPath> UAnimNotify_GSBase::GetSoftReferences() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GetSoftReferences");

	Params::AnimNotify_GSBase_GetSoftReferences Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.GSNotify_Delay
// (Final, Native, Public, HasOutParams, BlueprintCallable, Const)
// Parameters:
// struct FUStGSNotifyParam*               NotifyParam                                            (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UAnimNotify_GSBase::GSNotify_Delay(struct FUStGSNotifyParam* NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GSNotify_Delay");

	Params::AnimNotify_GSBase_GSNotify_Delay Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function b1.AnimNotify_GSBase.GSNotifyCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UAnimNotify_GSBase::GSNotifyCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GSNotifyCS");

	Params::AnimNotify_GSBase_GSNotifyCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.AnimNotify_GSBase.GSPostNotifyDebugCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotify_GSBase::GSPostNotifyDebugCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GSPostNotifyDebugCS");

	Params::AnimNotify_GSBase_GSPostNotifyDebugCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.GSPreNotifyDebugCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const struct FUStGSNotifyParam&         NotifyParam                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAnimNotify_GSBase::GSPreNotifyDebugCS(const struct FUStGSNotifyParam& NotifyParam) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GSPreNotifyDebugCS");

	Params::AnimNotify_GSBase_GSPreNotifyDebugCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.AnimNotify_GSBase.GSValidateInputCS
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimNotify_GSBase::GSValidateInputCS(class AActor* Actor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimNotify_GSBase", "GSValidateInputCS");

	Params::AnimNotify_GSBase_GSValidateInputCS Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibGM.TestIntPtr
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FIntPtr&                   InputPtr                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FIntPtr                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FIntPtr UBGUFuncLibGM::TestIntPtr(int32 Count, const struct FIntPtr& InputPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibGM", "TestIntPtr");

	Params::BGUFuncLibGM_TestIntPtr Parms{};

	Parms.Count = Count;
	Parms.InputPtr = std::move(InputPtr);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUComponentSweepMulti
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       TraceChannel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              PrimComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// TArray<struct FUStGSHitResult>*         SweepResults                                           (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        BlockChannelsForFilter                                 (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        OverlapChannelsForFilter                               (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGUComponentSweepMulti(class UObject* WorldContextObject, ECollisionChannel TraceChannel, class UPrimitiveComponent* PrimComp, const struct FVector& Start, const struct FVector& End, const struct FQuat& Rot, TArray<struct FUStGSHitResult>* SweepResults, const TArray<class AActor*>& IgnoreActors, const TArray<ECollisionChannel>& BlockChannelsForFilter, const TArray<ECollisionChannel>& OverlapChannelsForFilter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUComponentSweepMulti");

	Params::BGUFuncLibSelectTargets_BGUComponentSweepMulti Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TraceChannel = TraceChannel;
	Parms.PrimComp = PrimComp;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.Rot = std::move(Rot);
	Parms.IgnoreActors = std::move(IgnoreActors);
	Parms.BlockChannelsForFilter = std::move(BlockChannelsForFilter);
	Parms.OverlapChannelsForFilter = std::move(OverlapChannelsForFilter);

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUCompOverlapCompsByChannel
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Component                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       TraceChannel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           ComponentClassFilter                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            ActorsToIgnore                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>*     OutComponents                                          (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGUCompOverlapCompsByChannel(class UPrimitiveComponent* Component, ECollisionChannel TraceChannel, class UClass* ComponentClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUCompOverlapCompsByChannel");

	Params::BGUFuncLibSelectTargets_BGUCompOverlapCompsByChannel Parms{};

	Parms.Component = Component;
	Parms.TraceChannel = TraceChannel;
	Parms.ComponentClassFilter = ComponentClassFilter;
	Parms.ActorsToIgnore = std::move(ActorsToIgnore);

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUCompOverlapCompsByObjectType
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Component                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class UClass*                           ComponentClassFilter                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            ActorsToIgnore                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>*     OutComponents                                          (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGUCompOverlapCompsByObjectType(class UPrimitiveComponent* Component, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ComponentClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUCompOverlapCompsByObjectType");

	Params::BGUFuncLibSelectTargets_BGUCompOverlapCompsByObjectType Parms{};

	Parms.Component = Component;
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.ComponentClassFilter = ComponentClassFilter;
	Parms.ActorsToIgnore = std::move(ActorsToIgnore);

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUComputePenetration
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              SelfComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         Direction                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Distance                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComponent                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Pos                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGUComputePenetration(class UPrimitiveComponent* SelfComponent, struct FVector* Direction, float* Distance, class UPrimitiveComponent* OtherComponent, const struct FVector& Pos, const struct FQuat& Rot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUComputePenetration");

	Params::BGUFuncLibSelectTargets_BGUComputePenetration Parms{};

	Parms.SelfComponent = SelfComponent;
	Parms.OtherComponent = OtherComponent;
	Parms.Pos = std::move(Pos);
	Parms.Rot = std::move(Rot);

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

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

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUGetPerceivedActors
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UAIPerceptionComponent*     PerceptionComp                                         (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UBGUFuncLibSelectTargets::BGUGetPerceivedActors(const class UAIPerceptionComponent* PerceptionComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUGetPerceivedActors");

	Params::BGUFuncLibSelectTargets_BGUGetPerceivedActors Parms{};

	Parms.PerceptionComp = PerceptionComp;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUGetSightPerceivedActors
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UAIPerceptionComponent*     PerceptionComp                                         (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UBGUFuncLibSelectTargets::BGUGetSightPerceivedActors(const class UAIPerceptionComponent* PerceptionComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUGetSightPerceivedActors");

	Params::BGUFuncLibSelectTargets_BGUGetSightPerceivedActors Parms{};

	Parms.PerceptionComp = PerceptionComp;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUGetSweepCheckResultsByCollisionChannel
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                PreTransform                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FTransform&                CurTransform                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGSSweepCheckShapeInfo&    SweepCheckShapeInfo                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// TArray<struct FUStGSHitResult>*         SweepResults                                           (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        BlockChannelsForFilter                                 (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        OverlapChannelsForFilter                               (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    IsDrawDebugShape                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibSelectTargets::BGUGetSweepCheckResultsByCollisionChannel(class UObject* WorldContextObject, const struct FTransform& PreTransform, const struct FTransform& CurTransform, const struct FQuat& Rot, ECollisionChannel CollisionChannel, const struct FGSSweepCheckShapeInfo& SweepCheckShapeInfo, TArray<struct FUStGSHitResult>* SweepResults, const TArray<class AActor*>& IgnoreActors, const TArray<ECollisionChannel>& BlockChannelsForFilter, const TArray<ECollisionChannel>& OverlapChannelsForFilter, bool IsDrawDebugShape)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUGetSweepCheckResultsByCollisionChannel");

	Params::BGUFuncLibSelectTargets_BGUGetSweepCheckResultsByCollisionChannel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PreTransform = std::move(PreTransform);
	Parms.CurTransform = std::move(CurTransform);
	Parms.Rot = std::move(Rot);
	Parms.CollisionChannel = CollisionChannel;
	Parms.SweepCheckShapeInfo = std::move(SweepCheckShapeInfo);
	Parms.IgnoreActors = std::move(IgnoreActors);
	Parms.BlockChannelsForFilter = std::move(BlockChannelsForFilter);
	Parms.OverlapChannelsForFilter = std::move(OverlapChannelsForFilter);
	Parms.IsDrawDebugShape = IsDrawDebugShape;

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

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

	Func->FunctionFlags = Flgs;

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


// Function b1.BGUFuncLibSelectTargets.BGUGetSweepCheckResultsByCollisionChannelWithCaster
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                PreTransform                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FTransform&                CurTransform                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGSSweepCheckShapeInfo&    SweepCheckShapeInfo                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// TArray<struct FUStGSHitResult>*         SweepResults                                           (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    BlockChannelsForFilter                                 (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    OverlapChannelsForFilter                               (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    IsDrawDebugShape                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Caster                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GroupId                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ESweepCheckType                         SweepCheckType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibSelectTargets::BGUGetSweepCheckResultsByCollisionChannelWithCaster(class UObject* WorldContextObject, const struct FTransform& PreTransform, const struct FTransform& CurTransform, const struct FQuat& Rot, ECollisionChannel CollisionChannel, const struct FGSSweepCheckShapeInfo& SweepCheckShapeInfo, TArray<struct FUStGSHitResult>* SweepResults, const TArray<class AActor*>& IgnoreActors, const TArray<uint8>& BlockChannelsForFilter, const TArray<uint8>& OverlapChannelsForFilter, bool IsDrawDebugShape, class AActor* Caster, int32 GroupId, ESweepCheckType SweepCheckType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUGetSweepCheckResultsByCollisionChannelWithCaster");

	Params::BGUFuncLibSelectTargets_BGUGetSweepCheckResultsByCollisionChannelWithCaster Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PreTransform = std::move(PreTransform);
	Parms.CurTransform = std::move(CurTransform);
	Parms.Rot = std::move(Rot);
	Parms.CollisionChannel = CollisionChannel;
	Parms.SweepCheckShapeInfo = std::move(SweepCheckShapeInfo);
	Parms.IgnoreActors = std::move(IgnoreActors);
	Parms.BlockChannelsForFilter = std::move(BlockChannelsForFilter);
	Parms.OverlapChannelsForFilter = std::move(OverlapChannelsForFilter);
	Parms.IsDrawDebugShape = IsDrawDebugShape;
	Parms.Caster = Caster;
	Parms.GroupId = GroupId;
	Parms.SweepCheckType = SweepCheckType;

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

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

	Func->FunctionFlags = Flgs;

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


// Function b1.BGUFuncLibSelectTargets.BGUIsSelectTargetInFilterBP
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Caster                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Filter                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGUIsSelectTargetInFilterBP(class AActor* Caster, class AActor* Target, int32 Filter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUIsSelectTargetInFilterBP");

	Params::BGUFuncLibSelectTargets_BGUIsSelectTargetInFilterBP Parms{};

	Parms.Caster = Caster;
	Parms.Target = Target;
	Parms.Filter = Filter;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGULineTraceMultiByCollisionChannel
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FUStGSHitResult>*         SweepResults                                           (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        BlockChannelsForFilter                                 (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        OverlapChannelsForFilter                               (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    IsDrawDebug                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGULineTraceMultiByCollisionChannel(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, ECollisionChannel CollisionChannel, TArray<struct FUStGSHitResult>* SweepResults, const TArray<class AActor*>& IgnoreActors, const TArray<ECollisionChannel>& BlockChannelsForFilter, const TArray<ECollisionChannel>& OverlapChannelsForFilter, bool IsDrawDebug)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGULineTraceMultiByCollisionChannel");

	Params::BGUFuncLibSelectTargets_BGULineTraceMultiByCollisionChannel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.CollisionChannel = CollisionChannel;
	Parms.IgnoreActors = std::move(IgnoreActors);
	Parms.BlockChannelsForFilter = std::move(BlockChannelsForFilter);
	Parms.OverlapChannelsForFilter = std::move(OverlapChannelsForFilter);
	Parms.IsDrawDebug = IsDrawDebug;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGULineTraceSingleByCollisionChannel
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FUStGSHitResult*                 SweepResult                                            (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        BlockChannelsForFilter                                 (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<ECollisionChannel>&        OverlapChannelsForFilter                               (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    IsDrawDebug                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGULineTraceSingleByCollisionChannel(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, ECollisionChannel CollisionChannel, struct FUStGSHitResult* SweepResult, const TArray<class AActor*>& IgnoreActors, const TArray<ECollisionChannel>& BlockChannelsForFilter, const TArray<ECollisionChannel>& OverlapChannelsForFilter, bool IsDrawDebug)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGULineTraceSingleByCollisionChannel");

	Params::BGUFuncLibSelectTargets_BGULineTraceSingleByCollisionChannel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.CollisionChannel = CollisionChannel;
	Parms.IgnoreActors = std::move(IgnoreActors);
	Parms.BlockChannelsForFilter = std::move(BlockChannelsForFilter);
	Parms.OverlapChannelsForFilter = std::move(OverlapChannelsForFilter);
	Parms.IsDrawDebug = IsDrawDebug;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUMultiCompOverlapByObjectType
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UShapeComponent*>&   OverlapShapeComponents                                 (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UShapeComponent*>*         OverlapComps                                           (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  OverlapOtherActors                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>*     OverlapOtherComps                                      (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGUMultiCompOverlapByObjectType(class UObject* WorldContextObject, const TArray<class UShapeComponent*>& OverlapShapeComponents, const TArray<EObjectTypeQuery>& ObjectTypes, const TArray<class AActor*>& IgnoreActors, TArray<class UShapeComponent*>* OverlapComps, TArray<class AActor*>* OverlapOtherActors, TArray<class UPrimitiveComponent*>* OverlapOtherComps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUMultiCompOverlapByObjectType");

	Params::BGUFuncLibSelectTargets_BGUMultiCompOverlapByObjectType Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.OverlapShapeComponents = std::move(OverlapShapeComponents);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.IgnoreActors = std::move(IgnoreActors);

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

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

	Func->FunctionFlags = Flgs;

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

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

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

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUOverlapAnyTestByObjectType
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UWorld*                           WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Pos                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// EGSSweepCheckShapeType                  CollisionShape                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ShapeExtent                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFuncLibSelectTargets::BGUOverlapAnyTestByObjectType(class UWorld* WorldContextObject, const struct FVector& Pos, const TArray<EObjectTypeQuery>& ObjectTypes, EGSSweepCheckShapeType CollisionShape, const struct FVector& ShapeExtent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUOverlapAnyTestByObjectType");

	Params::BGUFuncLibSelectTargets_BGUOverlapAnyTestByObjectType Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Pos = std::move(Pos);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.CollisionShape = CollisionShape;
	Parms.ShapeExtent = std::move(ShapeExtent);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibSelectTargets.BGUOverlapMultiByObjectType
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Origin                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGSSweepCheckShapeInfo&    OverlapShapeInfo                                       (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FUStGSOverlapResult>*     OverlapResults                                         (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    IsDrawDebugShape                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFuncLibSelectTargets::BGUOverlapMultiByObjectType(class UObject* WorldContextObject, const struct FVector& Origin, const struct FQuat& Rot, const TArray<EObjectTypeQuery>& ObjectTypes, const struct FGSSweepCheckShapeInfo& OverlapShapeInfo, const TArray<class AActor*>& IgnoreActors, TArray<struct FUStGSOverlapResult>* OverlapResults, bool IsDrawDebugShape)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibSelectTargets", "BGUOverlapMultiByObjectType");

	Params::BGUFuncLibSelectTargets_BGUOverlapMultiByObjectType Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Origin = std::move(Origin);
	Parms.Rot = std::move(Rot);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.OverlapShapeInfo = std::move(OverlapShapeInfo);
	Parms.IgnoreActors = std::move(IgnoreActors);
	Parms.IsDrawDebugShape = IsDrawDebugShape;

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

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

	Func->FunctionFlags = Flgs;

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


// Function b1.AutoMovePerfEditorVisualizer.ClearVisualizedPerfInfo
// (Final, Native, Public, BlueprintCallable)

void AAutoMovePerfEditorVisualizer::ClearVisualizedPerfInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoMovePerfEditorVisualizer", "ClearVisualizedPerfInfo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.AutoMovePerfEditorVisualizer.DisplayVisualizedPerfInfo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const TArray<float>&                    InTileSourceInfoArray                                  (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const struct FVector2D&                 InResolution                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FIntPoint&                 InTileCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InIntensityScaleFactor                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InBaseImagePath                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAutoMovePerfEditorVisualizer::DisplayVisualizedPerfInfo(const TArray<float>& InTileSourceInfoArray, const struct FVector2D& InResolution, const struct FIntPoint& InTileCount, float InIntensityScaleFactor, const class FString& InBaseImagePath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoMovePerfEditorVisualizer", "DisplayVisualizedPerfInfo");

	Params::AutoMovePerfEditorVisualizer_DisplayVisualizedPerfInfo Parms{};

	Parms.InTileSourceInfoArray = std::move(InTileSourceInfoArray);
	Parms.InResolution = std::move(InResolution);
	Parms.InTileCount = std::move(InTileCount);
	Parms.InIntensityScaleFactor = InIntensityScaleFactor;
	Parms.InBaseImagePath = std::move(InBaseImagePath);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.ActorChannelOpenAcked
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSE_OnlineFuncLib::ActorChannelOpenAcked(class AActor* Actor, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "ActorChannelOpenAcked");

	Params::GSE_OnlineFuncLib_ActorChannelOpenAcked Parms{};

	Parms.Actor = Actor;
	Parms.PlayerController = PlayerController;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.ActorChannelValid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSE_OnlineFuncLib::ActorChannelValid(class AActor* Actor, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "ActorChannelValid");

	Params::GSE_OnlineFuncLib_ActorChannelValid Parms{};

	Parms.Actor = Actor;
	Parms.PlayerController = PlayerController;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.CloseActorChannelByActorAndPlayerController
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CloseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSE_OnlineFuncLib::CloseActorChannelByActorAndPlayerController(class AActor* Actor, class APlayerController* PlayerController, int32 CloseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "CloseActorChannelByActorAndPlayerController");

	Params::GSE_OnlineFuncLib_CloseActorChannelByActorAndPlayerController Parms{};

	Parms.Actor = Actor;
	Parms.PlayerController = PlayerController;
	Parms.CloseReason = CloseReason;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.CloseClientConnection
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EGSNetCloseResult                       CloseResult                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                ClientPlayerController                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSE_OnlineFuncLib::CloseClientConnection(EGSNetCloseResult CloseResult, class APlayerController* ClientPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "CloseClientConnection");

	Params::GSE_OnlineFuncLib_CloseClientConnection Parms{};

	Parms.CloseResult = CloseResult;
	Parms.ClientPlayerController = ClientPlayerController;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.CloseServerConnection
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EGSNetCloseResult                       CloseResult                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSE_OnlineFuncLib::CloseServerConnection(EGSNetCloseResult CloseResult, class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "CloseServerConnection");

	Params::GSE_OnlineFuncLib_CloseServerConnection Parms{};

	Parms.CloseResult = CloseResult;
	Parms.WorldContext = WorldContext;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.ForceRemoveNetGuid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSE_OnlineFuncLib::ForceRemoveNetGuid(class UObject* Obj)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "ForceRemoveNetGuid");

	Params::GSE_OnlineFuncLib_ForceRemoveNetGuid Parms{};

	Parms.Obj = Obj;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GEngineHandleDisconnect
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSE_OnlineFuncLib::GEngineHandleDisconnect(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GEngineHandleDisconnect");

	Params::GSE_OnlineFuncLib_GEngineHandleDisconnect Parms{};

	Parms.World = World;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.GetActorChannelActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UActorChannel*                    Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UGSE_OnlineFuncLib::GetActorChannelActor(class UActorChannel* Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetActorChannelActor");

	Params::GSE_OnlineFuncLib_GetActorChannelActor Parms{};

	Parms.Channel = Channel;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetGameDefaultMap
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UGSE_OnlineFuncLib::GetGameDefaultMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetGameDefaultMap");

	Params::GSE_OnlineFuncLib_GetGameDefaultMap Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetObjByNetGuid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldCtx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   Guid                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UGSE_OnlineFuncLib::GetObjByNetGuid(class UObject* WorldCtx, int64 Guid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetObjByNetGuid");

	Params::GSE_OnlineFuncLib_GetObjByNetGuid Parms{};

	Parms.WorldCtx = WorldCtx;
	Parms.Guid = Guid;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetObjNetGuid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int64 UGSE_OnlineFuncLib::GetObjNetGuid(class UObject* Obj)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetObjNetGuid");

	Params::GSE_OnlineFuncLib_GetObjNetGuid Parms{};

	Parms.Obj = Obj;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetObjNetGuidByChannel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UActorChannel*                    Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int64 UGSE_OnlineFuncLib::GetObjNetGuidByChannel(class UActorChannel* Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetObjNetGuidByChannel");

	Params::GSE_OnlineFuncLib_GetObjNetGuidByChannel Parms{};

	Parms.Channel = Channel;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetReplicationGraph
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldCtx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UGSE_OnlineFuncLib::GetReplicationGraph(class UObject* WorldCtx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetReplicationGraph");

	Params::GSE_OnlineFuncLib_GetReplicationGraph Parms{};

	Parms.WorldCtx = WorldCtx;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetUniqueNetIdStringByFUniqueNetIdRepl
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          UniqueId                                               (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UGSE_OnlineFuncLib::GetUniqueNetIdStringByFUniqueNetIdRepl(const struct FUniqueNetIdRepl& UniqueId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetUniqueNetIdStringByFUniqueNetIdRepl");

	Params::GSE_OnlineFuncLib_GetUniqueNetIdStringByFUniqueNetIdRepl Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetUniqueNetIdStringByPlayerController
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                Controller                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UGSE_OnlineFuncLib::GetUniqueNetIdStringByPlayerController(class APlayerController* Controller)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetUniqueNetIdStringByPlayerController");

	Params::GSE_OnlineFuncLib_GetUniqueNetIdStringByPlayerController Parms{};

	Parms.Controller = Controller;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.GetUniqueNetIdStringByPlayerState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerState*                     PlayerState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UGSE_OnlineFuncLib::GetUniqueNetIdStringByPlayerState(class APlayerState* PlayerState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "GetUniqueNetIdStringByPlayerState");

	Params::GSE_OnlineFuncLib_GetUniqueNetIdStringByPlayerState Parms{};

	Parms.PlayerState = PlayerState;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.InServerReal
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldCtx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSE_OnlineFuncLib::InServerReal(class UObject* WorldCtx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "InServerReal");

	Params::GSE_OnlineFuncLib_InServerReal Parms{};

	Parms.WorldCtx = WorldCtx;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.IsActorChannelReadyForClient
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSE_OnlineFuncLib::IsActorChannelReadyForClient(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "IsActorChannelReadyForClient");

	Params::GSE_OnlineFuncLib_IsActorChannelReadyForClient Parms{};

	Parms.Actor = Actor;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.IsActorChannelReadyForServer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSE_OnlineFuncLib::IsActorChannelReadyForServer(class AActor* Actor, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "IsActorChannelReadyForServer");

	Params::GSE_OnlineFuncLib_IsActorChannelReadyForServer Parms{};

	Parms.Actor = Actor;
	Parms.PlayerController = PlayerController;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.MarkActorRoleDirty
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSE_OnlineFuncLib::MarkActorRoleDirty(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "MarkActorRoleDirty");

	Params::GSE_OnlineFuncLib_MarkActorRoleDirty Parms{};

	Parms.Actor = Actor;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.RegisterNetGuid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int64                                   Guid                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSE_OnlineFuncLib::RegisterNetGuid(int64 Guid, class UObject* Obj)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "RegisterNetGuid");

	Params::GSE_OnlineFuncLib_RegisterNetGuid Parms{};

	Parms.Guid = Guid;
	Parms.Obj = Obj;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.ResetNetGuidAckStat
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int64                                   Guid                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNetConnection*                   NetConnection                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSE_OnlineFuncLib::ResetNetGuidAckStat(int64 Guid, class UNetConnection* NetConnection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "ResetNetGuidAckStat");

	Params::GSE_OnlineFuncLib_ResetNetGuidAckStat Parms{};

	Parms.Guid = Guid;
	Parms.NetConnection = NetConnection;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.ServerReplicateOneActorToPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int64 UGSE_OnlineFuncLib::ServerReplicateOneActorToPlayer(class AActor* Actor, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "ServerReplicateOneActorToPlayer");

	Params::GSE_OnlineFuncLib_ServerReplicateOneActorToPlayer Parms{};

	Parms.Actor = Actor;
	Parms.PlayerController = PlayerController;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSE_OnlineFuncLib.SetGameDefaultMap
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    NewMap                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSE_OnlineFuncLib::SetGameDefaultMap(const class FString& NewMap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "SetGameDefaultMap");

	Params::GSE_OnlineFuncLib_SetGameDefaultMap Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.GSE_OnlineFuncLib.SlowMakeUniqueObjectName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Parent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UClass*                     Class_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             InBaseName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UGSE_OnlineFuncLib::SlowMakeUniqueObjectName(class UObject* Parent, const class UClass* Class_0, class FName InBaseName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GSE_OnlineFuncLib", "SlowMakeUniqueObjectName");

	Params::GSE_OnlineFuncLib_SlowMakeUniqueObjectName Parms{};

	Parms.Parent = Parent;
	Parms.Class_0 = Class_0;
	Parms.InBaseName = InBaseName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1OnlineSession.ClearOnlineDelegatesCS
// (Event, Public, BlueprintEvent)

void UB1OnlineSession::ClearOnlineDelegatesCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1OnlineSession", "ClearOnlineDelegatesCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1OnlineSession.EndOnlineSessionCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             SessionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1OnlineSession::EndOnlineSessionCS(class FName SessionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1OnlineSession", "EndOnlineSessionCS");

	Params::B1OnlineSession_EndOnlineSessionCS Parms{};

	Parms.SessionName = SessionName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1OnlineSession.HandleDisconnectCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNetDriver*                       NetDriver                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1OnlineSession::HandleDisconnectCS(class UWorld* World, class UNetDriver* NetDriver)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1OnlineSession", "HandleDisconnectCS");

	Params::B1OnlineSession_HandleDisconnectCS Parms{};

	Parms.World = World;
	Parms.NetDriver = NetDriver;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1OnlineSession.OnSessionUserInviteAcceptedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// const bool                              bWasSuccess                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ControllerId                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1OnlineSession::OnSessionUserInviteAcceptedCS(const bool bWasSuccess, const int32 ControllerId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1OnlineSession", "OnSessionUserInviteAcceptedCS");

	Params::B1OnlineSession_OnSessionUserInviteAcceptedCS Parms{};

	Parms.bWasSuccess = bWasSuccess;
	Parms.ControllerId = ControllerId;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1OnlineSession.RegisterOnlineDelegatesCS
// (Event, Public, BlueprintEvent)

void UB1OnlineSession::RegisterOnlineDelegatesCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1OnlineSession", "RegisterOnlineDelegatesCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1OnlineSession.StartOnlineSessionCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             SessionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1OnlineSession::StartOnlineSessionCS(class FName SessionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1OnlineSession", "StartOnlineSessionCS");

	Params::B1OnlineSession_StartOnlineSessionCS Parms{};

	Parms.SessionName = SessionName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1NetReplicationGraphConnection.GetPlayerControllerCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APlayerController* UB1NetReplicationGraphConnection::GetPlayerControllerCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1NetReplicationGraphConnection", "GetPlayerControllerCS");

	Params::B1NetReplicationGraphConnection_GetPlayerControllerCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1NetReplicationGraphConnection.GSAddB1ActorChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1NetReplicationGraphConnection::GSAddB1ActorChannel(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1NetReplicationGraphConnection", "GSAddB1ActorChannel");

	Params::B1NetReplicationGraphConnection_GSAddB1ActorChannel Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1NetReplicationGraphConnection.IsInServerReal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1NetReplicationGraphConnection::IsInServerReal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1NetReplicationGraphConnection", "IsInServerReal");

	Params::B1NetReplicationGraphConnection_IsInServerReal Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1NetReplicationGraphConnection.NotifyActorChannelAddedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorChannel*                    Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1NetReplicationGraphConnection::NotifyActorChannelAddedCS(class AActor* Actor, class UActorChannel* Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1NetReplicationGraphConnection", "NotifyActorChannelAddedCS");

	Params::B1NetReplicationGraphConnection_NotifyActorChannelAddedCS Parms{};

	Parms.Actor = Actor;
	Parms.Channel = Channel;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1NetReplicationGraphConnection.NotifyActorChannelCleanedUpCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UActorChannel*                    ActorChannel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CloseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1NetReplicationGraphConnection::NotifyActorChannelCleanedUpCS(class UActorChannel* ActorChannel, int32 CloseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1NetReplicationGraphConnection", "NotifyActorChannelCleanedUpCS");

	Params::B1NetReplicationGraphConnection_NotifyActorChannelCleanedUpCS Parms{};

	Parms.ActorChannel = ActorChannel;
	Parms.CloseReason = CloseReason;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1NetReplicationGraphConnection.NotifyActorChannelRemovedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1NetReplicationGraphConnection::NotifyActorChannelRemovedCS(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1NetReplicationGraphConnection", "NotifyActorChannelRemovedCS");

	Params::B1NetReplicationGraphConnection_NotifyActorChannelRemovedCS Parms{};

	Parms.Actor = Actor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1NetReplicationGraphConnection.SetActorNotDormantOnConnectionCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1NetReplicationGraphConnection::SetActorNotDormantOnConnectionCS(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1NetReplicationGraphConnection", "SetActorNotDormantOnConnectionCS");

	Params::B1NetReplicationGraphConnection_SetActorNotDormantOnConnectionCS Parms{};

	Parms.InActor = InActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.AddBGUCharacterToAlwaysRelevantNodeCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABGUCharacter*                    Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::AddBGUCharacterToAlwaysRelevantNodeCS(class ABGUCharacter* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "AddBGUCharacterToAlwaysRelevantNodeCS");

	Params::B1ReplicationGraph_AddBGUCharacterToAlwaysRelevantNodeCS Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.AddConnectionGraphNodeCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UReplicationGraphNode*            GraphNode                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNetReplicationGraphConnection*   ConnectionManager                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::AddConnectionGraphNodeCS(class UReplicationGraphNode* GraphNode, class UNetReplicationGraphConnection* ConnectionManager)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "AddConnectionGraphNodeCS");

	Params::B1ReplicationGraph_AddConnectionGraphNodeCS Parms{};

	Parms.GraphNode = GraphNode;
	Parms.ConnectionManager = ConnectionManager;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.AddNetworkActorCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::AddNetworkActorCS(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "AddNetworkActorCS");

	Params::B1ReplicationGraph_AddNetworkActorCS Parms{};

	Parms.Actor = Actor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1ReplicationGraph.ClienResetActorChannelCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABGUCharacter*                    Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::ClienResetActorChannelCS(class ABGUCharacter* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "ClienResetActorChannelCS");

	Params::B1ReplicationGraph_ClienResetActorChannelCS Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.GetConnectionByIndexCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Idx                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNetReplicationGraphConnection*   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNetReplicationGraphConnection* UB1ReplicationGraph::GetConnectionByIndexCS(int32 Idx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "GetConnectionByIndexCS");

	Params::B1ReplicationGraph_GetConnectionByIndexCS Parms{};

	Parms.Idx = Idx;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1ReplicationGraph.GetReplicationGraphConnectionByPC
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UB1NetReplicationGraphConnection* ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UB1NetReplicationGraphConnection* UB1ReplicationGraph::GetReplicationGraphConnectionByPC(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "GetReplicationGraphConnectionByPC");

	Params::B1ReplicationGraph_GetReplicationGraphConnectionByPC Parms{};

	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1ReplicationGraph.GetServerConnectionCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UNetConnection*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNetConnection* UB1ReplicationGraph::GetServerConnectionCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "GetServerConnectionCS");

	Params::B1ReplicationGraph_GetServerConnectionCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1ReplicationGraph.GetWorldCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWorld* UB1ReplicationGraph::GetWorldCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "GetWorldCS");

	Params::B1ReplicationGraph_GetWorldCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1ReplicationGraph.GSNetworkRemapPathCS
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class UObject*                    Outer_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    OriginName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          Name_0                                                 (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::GSNetworkRemapPathCS(const class UObject* Outer_0, const class FString& OriginName, class FString* Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "GSNetworkRemapPathCS");

	Params::B1ReplicationGraph_GSNetworkRemapPathCS Parms{};

	Parms.Outer_0 = Outer_0;
	Parms.OriginName = std::move(OriginName);

	UObject::ProcessEvent(Func, &Parms);

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


// Function b1.B1ReplicationGraph.InitConnectionGraphNodesCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UNetReplicationGraphConnection*   RepGraphConnection                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::InitConnectionGraphNodesCS(class UNetReplicationGraphConnection* RepGraphConnection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "InitConnectionGraphNodesCS");

	Params::B1ReplicationGraph_InitConnectionGraphNodesCS Parms{};

	Parms.RepGraphConnection = RepGraphConnection;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1ReplicationGraph.InitGlobalActorClassSettingsCS
// (Event, Public, BlueprintEvent)

void UB1ReplicationGraph::InitGlobalActorClassSettingsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "InitGlobalActorClassSettingsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1ReplicationGraph.InitGlobalGraphNodesCS
// (Event, Public, BlueprintEvent)

void UB1ReplicationGraph::InitGlobalGraphNodesCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "InitGlobalGraphNodesCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1ReplicationGraph.InitNodeCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UB1ReplicationGraphNode_CSBase*   CSNode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::InitNodeCS(class UB1ReplicationGraphNode_CSBase* CSNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "InitNodeCS");

	Params::B1ReplicationGraph_InitNodeCS Parms{};

	Parms.CSNode = CSNode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.RemoveBGUCharacterFromAlwaysRelevantNodeCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABGUCharacter*                    Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::RemoveBGUCharacterFromAlwaysRelevantNodeCS(class ABGUCharacter* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "RemoveBGUCharacterFromAlwaysRelevantNodeCS");

	Params::B1ReplicationGraph_RemoveBGUCharacterFromAlwaysRelevantNodeCS Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.RemoveConnectionGraphNodeCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UReplicationGraphNode*            GraphNode                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNetReplicationGraphConnection*   ConnectionManager                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::RemoveConnectionGraphNodeCS(class UReplicationGraphNode* GraphNode, class UNetReplicationGraphConnection* ConnectionManager)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "RemoveConnectionGraphNodeCS");

	Params::B1ReplicationGraph_RemoveConnectionGraphNodeCS Parms{};

	Parms.GraphNode = GraphNode;
	Parms.ConnectionManager = ConnectionManager;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.RemoveNetworkActorCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::RemoveNetworkActorCS(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "RemoveNetworkActorCS");

	Params::B1ReplicationGraph_RemoveNetworkActorCS Parms{};

	Parms.Actor = Actor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1ReplicationGraph.ResetGameWorldStateCS
// (Event, Public, BlueprintEvent)

void UB1ReplicationGraph::ResetGameWorldStateCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "ResetGameWorldStateCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1ReplicationGraph.RouteAddNetworkActorToNodesCS
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::RouteAddNetworkActorToNodesCS(class AActor* Actor, const struct FVector& WorldLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "RouteAddNetworkActorToNodesCS");

	Params::B1ReplicationGraph_RouteAddNetworkActorToNodesCS Parms{};

	Parms.Actor = Actor;
	Parms.WorldLocation = std::move(WorldLocation);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1ReplicationGraph.RouteRemoveNetworkActorToNodesCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::RouteRemoveNetworkActorToNodesCS(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "RouteRemoveNetworkActorToNodesCS");

	Params::B1ReplicationGraph_RouteRemoveNetworkActorToNodesCS Parms{};

	Parms.Actor = Actor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1ReplicationGraph.SetAlwaysRelevantNodeCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UB1ReplicationGraphNode_CSBase*   AlwaysRelevantNodeCS                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::SetAlwaysRelevantNodeCS(class UB1ReplicationGraphNode_CSBase* AlwaysRelevantNodeCS)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "SetAlwaysRelevantNodeCS");

	Params::B1ReplicationGraph_SetAlwaysRelevantNodeCS Parms{};

	Parms.AlwaysRelevantNodeCS = AlwaysRelevantNodeCS;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.SetGlobalReplicationClassInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UClass*                           ReplicatedClass                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CullDistanceSquared                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReplicationPeriodFrame                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::SetGlobalReplicationClassInfo(class UClass* ReplicatedClass, float CullDistanceSquared, int32 ReplicationPeriodFrame)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "SetGlobalReplicationClassInfo");

	Params::B1ReplicationGraph_SetGlobalReplicationClassInfo Parms{};

	Parms.ReplicatedClass = ReplicatedClass;
	Parms.CullDistanceSquared = CullDistanceSquared;
	Parms.ReplicationPeriodFrame = ReplicationPeriodFrame;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.SetRoleSwapOnReplicateCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Swap                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraph::SetRoleSwapOnReplicateCS(class AActor* Actor, bool Swap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "SetRoleSwapOnReplicateCS");

	Params::B1ReplicationGraph_SetRoleSwapOnReplicateCS Parms{};

	Parms.Actor = Actor;
	Parms.Swap = Swap;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1ReplicationGraph.ShouldServerMultiCastRPCForPlayerCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                Controller                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   FuncAddr                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1ReplicationGraph::ShouldServerMultiCastRPCForPlayerCS(class APlayerController* Controller, class AActor* Actor, int64 FuncAddr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraph", "ShouldServerMultiCastRPCForPlayerCS");

	Params::B1ReplicationGraph_ShouldServerMultiCastRPCForPlayerCS Parms{};

	Parms.Controller = Controller;
	Parms.Actor = Actor;
	Parms.FuncAddr = FuncAddr;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.B1ReplicationGraphNode_CSBase.GatherActorListsForConnectionCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraphNode_CSBase::GatherActorListsForConnectionCS(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraphNode_CSBase", "GatherActorListsForConnectionCS");

	Params::B1ReplicationGraphNode_CSBase_GatherActorListsForConnectionCS Parms{};

	Parms.PlayerController = PlayerController;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1ReplicationGraphNode_CSBase.NotifyAddNetworkActorCS
// (Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraphNode_CSBase::NotifyAddNetworkActorCS(const class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraphNode_CSBase", "NotifyAddNetworkActorCS");

	Params::B1ReplicationGraphNode_CSBase_NotifyAddNetworkActorCS Parms{};

	Parms.Actor = Actor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1ReplicationGraphNode_CSBase.NotifyRemoveNetworkActorCS
// (Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWarnIfNotFound                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1ReplicationGraphNode_CSBase::NotifyRemoveNetworkActorCS(const class AActor* Actor, bool bWarnIfNotFound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraphNode_CSBase", "NotifyRemoveNetworkActorCS");

	Params::B1ReplicationGraphNode_CSBase_NotifyRemoveNetworkActorCS Parms{};

	Parms.Actor = Actor;
	Parms.bWarnIfNotFound = bWarnIfNotFound;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.B1ReplicationGraphNode_CSBase.NotifyResetAllNetworkActorsCS
// (Event, Public, BlueprintEvent)

void UB1ReplicationGraphNode_CSBase::NotifyResetAllNetworkActorsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraphNode_CSBase", "NotifyResetAllNetworkActorsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1ReplicationGraphNode_CSBase.PostServerReplicateActorCS
// (Event, Public, BlueprintEvent)

void UB1ReplicationGraphNode_CSBase::PostServerReplicateActorCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraphNode_CSBase", "PostServerReplicateActorCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1ReplicationGraphNode_CSBase.PrepareForReplicationCS
// (Event, Public, BlueprintEvent)

void UB1ReplicationGraphNode_CSBase::PrepareForReplicationCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraphNode_CSBase", "PrepareForReplicationCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.B1ReplicationGraphNode_CSBase.LogNodeCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// int32                                   Flag                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    NodeName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1ReplicationGraphNode_CSBase::LogNodeCS(int32 Flag, const class FString& NodeName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("B1ReplicationGraphNode_CSBase", "LogNodeCS");

	Params::B1ReplicationGraphNode_CSBase_LogNodeCS Parms{};

	Parms.Flag = Flag;
	Parms.NodeName = std::move(NodeName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.B1Util.CheckIsSimulationPlayMode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1Util::CheckIsSimulationPlayMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "CheckIsSimulationPlayMode");

	Params::B1Util_CheckIsSimulationPlayMode Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.CopyStringToClipboard
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Text                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::CopyStringToClipboard(const class FString& Text)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "CopyStringToClipboard");

	Params::B1Util_CopyStringToClipboard Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.GetAgreementReaded
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetAgreementReaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetAgreementReaded");

	Params::B1Util_GetAgreementReaded Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetArchiveMarkFinish
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1Util::GetArchiveMarkFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetArchiveMarkFinish");

	Params::B1Util_GetArchiveMarkFinish Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetAvailableMaps
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class FString>*                  OutAvailableMaps                                       (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetAvailableMaps(TArray<class FString>* OutAvailableMaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetAvailableMaps");

	Params::B1Util_GetAvailableMaps Parms{};

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetFirstSettingFinish
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1Util::GetFirstSettingFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetFirstSettingFinish");

	Params::B1Util_GetFirstSettingFinish Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetGMCommandList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TMap<uint8, class FString>*             OutGMCommandList                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetGMCommandList(TMap<uint8, class FString>* OutGMCommandList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetGMCommandList");

	Params::B1Util_GetGMCommandList Parms{};

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetPrivacyAgreement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetPrivacyAgreement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetPrivacyAgreement");

	Params::B1Util_GetPrivacyAgreement Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetRandomNumberFloat
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   LeftNum                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RightNum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UB1Util::GetRandomNumberFloat(float LeftNum, float RightNum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetRandomNumberFloat");

	Params::B1Util_GetRandomNumberFloat Parms{};

	Parms.LeftNum = LeftNum;
	Parms.RightNum = RightNum;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetRandomNumberInt
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   LeftNum                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RightNum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetRandomNumberInt(int32 LeftNum, int32 RightNum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetRandomNumberInt");

	Params::B1Util_GetRandomNumberInt Parms{};

	Parms.LeftNum = LeftNum;
	Parms.RightNum = RightNum;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetStartCommandList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class FString>*                  OutStartCommandList                                    (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetStartCommandList(TArray<class FString>* OutStartCommandList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetStartCommandList");

	Params::B1Util_GetStartCommandList Parms{};

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetStartLevelName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UB1Util::GetStartLevelName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetStartLevelName");

	Params::B1Util_GetStartLevelName Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetUISettingCustomData
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TMap<class FString, class FString>*     OutDetailSettingData                                   (Parm, OutParm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetUISettingCustomData(TMap<class FString, class FString>* OutDetailSettingData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetUISettingCustomData");

	Params::B1Util_GetUISettingCustomData Parms{};

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetUISettingData
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TMap<class FString, class FString>*     OutUISettingData                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetUISettingData(TMap<class FString, class FString>* OutUISettingData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetUISettingData");

	Params::B1Util_GetUISettingData Parms{};

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.B1Util.GetUISettingPbTag
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UB1Util::GetUISettingPbTag()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "GetUISettingPbTag");

	Params::B1Util_GetUISettingPbTag Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.IsNeverShowStartupUI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1Util::IsNeverShowStartupUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "IsNeverShowStartupUI");

	Params::B1Util_IsNeverShowStartupUI Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.IsStartupConfigEnable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UB1Util::IsStartupConfigEnable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "IsStartupConfigEnable");

	Params::B1Util_IsStartupConfigEnable Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.B1Util.OpenFileBrowser
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    FolderPath                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::OpenFileBrowser(const class FString& FolderPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "OpenFileBrowser");

	Params::B1Util_OpenFileBrowser Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SaveGameUserSettings
// (Final, Native, Static, Public, BlueprintCallable)

void UB1Util::SaveGameUserSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SaveGameUserSettings");

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

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetAgreementReaded
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   NewValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetAgreementReaded(int32 NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetAgreementReaded");

	Params::B1Util_SetAgreementReaded Parms{};

	Parms.NewValue = NewValue;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetArchiveMarkFinish
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    NewValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetArchiveMarkFinish(bool NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetArchiveMarkFinish");

	Params::B1Util_SetArchiveMarkFinish Parms{};

	Parms.NewValue = NewValue;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetFirstSettingFinish
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    NewValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetFirstSettingFinish(bool NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetFirstSettingFinish");

	Params::B1Util_SetFirstSettingFinish Parms{};

	Parms.NewValue = NewValue;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetGMCommandList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TMap<uint8, class FString>&       InGMCommandList                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UB1Util::SetGMCommandList(const TMap<uint8, class FString>& InGMCommandList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetGMCommandList");

	Params::B1Util_SetGMCommandList Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetMainMonitorID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    MonitorID                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetMainMonitorID(const class FString& MonitorID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetMainMonitorID");

	Params::B1Util_SetMainMonitorID Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetNeverShowStartupUI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    bInNeverShowStartupUI                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetNeverShowStartupUI(bool bInNeverShowStartupUI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetNeverShowStartupUI");

	Params::B1Util_SetNeverShowStartupUI Parms{};

	Parms.bInNeverShowStartupUI = bInNeverShowStartupUI;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetPrivacyAgreement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   NewValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetPrivacyAgreement(int32 NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetPrivacyAgreement");

	Params::B1Util_SetPrivacyAgreement Parms{};

	Parms.NewValue = NewValue;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetStartCommandList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class FString>&            InStartCommandList                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UB1Util::SetStartCommandList(const TArray<class FString>& InStartCommandList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetStartCommandList");

	Params::B1Util_SetStartCommandList Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetStartLevelName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InStartLevelName                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetStartLevelName(const class FString& InStartLevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetStartLevelName");

	Params::B1Util_SetStartLevelName Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetStartupConfigEnable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetStartupConfigEnable(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetStartupConfigEnable");

	Params::B1Util_SetStartupConfigEnable Parms{};

	Parms.bEnable = bEnable;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetUISettingCustomData
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TMap<class FString, class FString>&DetailSettingData                                      (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UB1Util::SetUISettingCustomData(const TMap<class FString, class FString>& DetailSettingData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetUISettingCustomData");

	Params::B1Util_SetUISettingCustomData Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetUISettingData
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TMap<class FString, class FString>&SetUISettingData_0                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UB1Util::SetUISettingData(const TMap<class FString, class FString>& SetUISettingData_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetUISettingData");

	Params::B1Util_SetUISettingData Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.B1Util.SetUISettingPbTag
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   TagId                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UB1Util::SetUISettingPbTag(int32 TagId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("B1Util", "SetUISettingPbTag");

	Params::B1Util_SetUISettingPbTag Parms{};

	Parms.TagId = TagId;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.SmartActorGuidObj.CanManageStates
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ISmartActorGuidObj::CanManageStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SmartActorGuidObj", "CanManageStates");

	Params::SmartActorGuidObj_CanManageStates Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.SmartActorGuidObj.GetActorGuid
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutActorGuid                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ISmartActorGuidObj::GetActorGuid(class AActor* InActor, class FString* OutActorGuid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SmartActorGuidObj", "GetActorGuid");

	Params::SmartActorGuidObj_GetActorGuid Parms{};

	Parms.InActor = InActor;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.SmartActorGuidObj.GetActorGuidOptions
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FActorGuidOption>*        OutOptions                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ISmartActorGuidObj::GetActorGuidOptions(const class FString& PropertyName, TArray<struct FActorGuidOption>* OutOptions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SmartActorGuidObj", "GetActorGuidOptions");

	Params::SmartActorGuidObj_GetActorGuidOptions Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BaseActorComp.ApplyWorldOffsetCS
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   InOffset                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWorldShift                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBaseActorComp::ApplyWorldOffsetCS(const struct FVector& InOffset, bool bWorldShift)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "ApplyWorldOffsetCS");

	Params::BaseActorComp_ApplyWorldOffsetCS Parms{};

	Parms.InOffset = std::move(InOffset);
	Parms.bWorldShift = bWorldShift;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BaseActorComp.BeginPlayInCS
// (Event, Public, BlueprintEvent)

void UBaseActorComp::BeginPlayInCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "BeginPlayInCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BaseActorComp.EndPlayInCS
// (Event, Public, BlueprintEvent)
// Parameters:
// const EEndPlayReason                    EndPlayReason                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBaseActorComp::EndPlayInCS(const EEndPlayReason EndPlayReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "EndPlayInCS");

	Params::BaseActorComp_EndPlayInCS Parms{};

	Parms.EndPlayReason = EndPlayReason;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BaseActorComp.GetDebugID
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBaseActorComp::GetDebugID()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "GetDebugID");

	Params::BaseActorComp_GetDebugID Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BaseActorComp.GetLogLvl
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBaseActorComp::GetLogLvl()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "GetLogLvl");

	Params::BaseActorComp_GetLogLvl Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BaseActorComp.InitializeCS
// (Event, Public, BlueprintEvent)

void UBaseActorComp::InitializeCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "InitializeCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BaseActorComp.OnAttachInCS
// (Event, Public, BlueprintEvent)

void UBaseActorComp::OnAttachInCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "OnAttachInCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BaseActorComp.OnRegisterCS
// (Event, Public, BlueprintEvent)

void UBaseActorComp::OnRegisterCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "OnRegisterCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BaseActorComp.OnUnregisterCS
// (Event, Public, BlueprintEvent)

void UBaseActorComp::OnUnregisterCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "OnUnregisterCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BaseActorComp.PostInitPropertiesCS
// (Event, Public, BlueprintEvent)

void UBaseActorComp::PostInitPropertiesCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorComp", "PostInitPropertiesCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BaseActorCompTickable.TickComponentInCS
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBaseActorCompTickable::TickComponentInCS(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseActorCompTickable", "TickComponentInCS");

	Params::BaseActorCompTickable_TickComponentInCS Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BaseEditorTickableActorComp.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBaseEditorTickableActorComp::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseEditorTickableActorComp", "OnPropertyChanged");

	Params::BaseEditorTickableActorComp_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.SceneComponentTickable.BeginPlayGS
// (Event, Public, BlueprintEvent)

void USceneComponentTickable::BeginPlayGS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SceneComponentTickable", "BeginPlayGS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.SceneComponentTickable.EndPlayGS
// (Event, Public, BlueprintEvent)
// Parameters:
// const EEndPlayReason                    EndPlayReason                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USceneComponentTickable::EndPlayGS(const EEndPlayReason EndPlayReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SceneComponentTickable", "EndPlayGS");

	Params::SceneComponentTickable_EndPlayGS Parms{};

	Parms.EndPlayReason = EndPlayReason;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.SceneComponentTickable.TickComponentGS
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USceneComponentTickable::TickComponentGS(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SceneComponentTickable", "TickComponentGS");

	Params::SceneComponentTickable_TickComponentGS Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.EditorOnlyCompBase.GetParamDisplayNameCS
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCalliopeGuid&             ConfigGuid                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEditorOnlyCompBase::GetParamDisplayNameCS(const class FString& PropertyName, const struct FCalliopeGuid& ConfigGuid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EditorOnlyCompBase", "GetParamDisplayNameCS");

	Params::EditorOnlyCompBase_GetParamDisplayNameCS Parms{};

	Parms.PropertyName = std::move(PropertyName);
	Parms.ConfigGuid = std::move(ConfigGuid);

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.EditorOnlyCompBase.GetPossibleParamsCS
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FString&                    ParentPropertyName                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FCalliopeGuid>*           OutParamArray                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UEditorOnlyCompBase::GetPossibleParamsCS(const class FString& ParentPropertyName, const class FString& PropertyName, TArray<struct FCalliopeGuid>* OutParamArray)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EditorOnlyCompBase", "GetPossibleParamsCS");

	Params::EditorOnlyCompBase_GetPossibleParamsCS Parms{};

	Parms.ParentPropertyName = std::move(ParentPropertyName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);

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


// Function b1.EditorOnlyCompBase.PreSaveCS
// (Event, Public, BlueprintEvent)

void UEditorOnlyCompBase::PreSaveCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EditorOnlyCompBase", "PreSaveCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerCameraManager.OnBlendCompleteCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerCameraManager::OnBlendCompleteCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerCameraManager", "OnBlendCompleteCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerCameraManager.OnViewTargetChangedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                PC                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OldViewTarget                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           NewViewTarget                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerCameraManager::OnViewTargetChangedCS(class APlayerController* PC, class AActor* OldViewTarget, class AActor* NewViewTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerCameraManager", "OnViewTargetChangedCS");

	Params::BGPPlayerCameraManager_OnViewTargetChangedCS Parms{};

	Parms.PC = PC;
	Parms.OldViewTarget = OldViewTarget;
	Parms.NewViewTarget = NewViewTarget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGPPlayerCameraManager.SetViewTargetCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           NewViewTarget                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FViewTargetTransitionParams&TransitionParams                                       (Parm, NoDestructor, NativeAccessSpecifierPublic)

void ABGPPlayerCameraManager::SetViewTargetCS(class AActor* NewViewTarget, const struct FViewTargetTransitionParams& TransitionParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerCameraManager", "SetViewTargetCS");

	Params::BGPPlayerCameraManager_SetViewTargetCS Parms{};

	Parms.NewViewTarget = NewViewTarget;
	Parms.TransitionParams = std::move(TransitionParams);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGPPlayerCameraManager.UpdateCameraCS
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerCameraManager::UpdateCameraCS(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerCameraManager", "UpdateCameraCS");

	Params::BGPPlayerCameraManager_UpdateCameraCS Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGPPlayerCameraManager.GetPendingViewTargetCS
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* ABGPPlayerCameraManager::GetPendingViewTargetCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerCameraManager", "GetPendingViewTargetCS");

	Params::BGPPlayerCameraManager_GetPendingViewTargetCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerCameraManager.GetViewTargetCS
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* ABGPPlayerCameraManager::GetViewTargetCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerCameraManager", "GetViewTargetCS");

	Params::BGPPlayerCameraManager_GetViewTargetCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.GetCachedConsoleCommandCS
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ABGPPlayerController::GetCachedConsoleCommandCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGPPlayerController", "GetCachedConsoleCommandCS");

	Params::BGPPlayerController_GetCachedConsoleCommandCS Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.GetCachedConsoleWorldContext
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* ABGPPlayerController::GetCachedConsoleWorldContext()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGPPlayerController", "GetCachedConsoleWorldContext");

	Params::BGPPlayerController_GetCachedConsoleWorldContext Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.BeginPlayCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerController::BeginPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "BeginPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerController.ConsoleCommandCS
// (Event, Public, BlueprintEvent)
// Parameters:
// const class FString&                    Command                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerController::ConsoleCommandCS(const class FString& Command)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "ConsoleCommandCS");

	Params::BGPPlayerController_ConsoleCommandCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGPPlayerController.GetCameraBlendTimeToGo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABGPPlayerController::GetCameraBlendTimeToGo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetCameraBlendTimeToGo");

	Params::BGPPlayerController_GetCameraBlendTimeToGo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.GetIsShouldPerformFullTickWhenPaused
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGPPlayerController::GetIsShouldPerformFullTickWhenPaused()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetIsShouldPerformFullTickWhenPaused");

	Params::BGPPlayerController_GetIsShouldPerformFullTickWhenPaused Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.GetNetConnectionCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UNetConnection*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNetConnection* ABGPPlayerController::GetNetConnectionCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetNetConnectionCS");

	Params::BGPPlayerController_GetNetConnectionCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.GetPendingViewTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* ABGPPlayerController::GetPendingViewTarget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetPendingViewTarget");

	Params::BGPPlayerController_GetPendingViewTarget Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.GetSeamlessTravelActorListCS
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// bool                                    bToEntry                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  ActorList                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void ABGPPlayerController::GetSeamlessTravelActorListCS(bool bToEntry, TArray<class AActor*>* ActorList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetSeamlessTravelActorListCS");

	Params::BGPPlayerController_GetSeamlessTravelActorListCS Parms{};

	Parms.bToEntry = bToEntry;

	UObject::ProcessEvent(Func, &Parms);

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


// Function b1.BGPPlayerController.GetSpawnLocationCS
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ABGPPlayerController::GetSpawnLocationCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetSpawnLocationCS");

	Params::BGPPlayerController_GetSpawnLocationCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerController.InitInputSystemCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerController::InitInputSystemCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "InitInputSystemCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerController.OnPossessWithViewTargetBlend
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                            InPawn                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EViewTargetBlendFunction                BlendFunc                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendExp                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLockOutgoing                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    EnableBlendViewTarget                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerController::OnPossessWithViewTargetBlend(class APawn* InPawn, float BlendTime, EViewTargetBlendFunction BlendFunc, float BlendExp, bool bLockOutgoing, bool EnableBlendViewTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "OnPossessWithViewTargetBlend");

	Params::BGPPlayerController_OnPossessWithViewTargetBlend Parms{};

	Parms.InPawn = InPawn;
	Parms.BlendTime = BlendTime;
	Parms.BlendFunc = BlendFunc;
	Parms.BlendExp = BlendExp;
	Parms.bLockOutgoing = bLockOutgoing;
	Parms.EnableBlendViewTarget = EnableBlendViewTarget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGPPlayerController.OnRep_PawnCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerController::OnRep_PawnCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "OnRep_PawnCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerController.OnRep_PlayerStateCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerController::OnRep_PlayerStateCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "OnRep_PlayerStateCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerController.PostInitializeComponentsCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerController::PostInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "PostInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerController.SetIsShouldPerformFullTickWhenPaused
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    IsShould                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerController::SetIsShouldPerformFullTickWhenPaused(bool IsShould)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "SetIsShouldPerformFullTickWhenPaused");

	Params::BGPPlayerController_SetIsShouldPerformFullTickWhenPaused Parms{};

	Parms.IsShould = IsShould;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGPPlayerController.SetSpawnLocationCS
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   NewLocation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerController::SetSpawnLocationCS(const struct FVector& NewLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "SetSpawnLocationCS");

	Params::BGPPlayerController_SetSpawnLocationCS Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGPPlayerController.GetAudioListenerPositionCS
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutFrontDir                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutRightDir                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerController::GetAudioListenerPositionCS(struct FVector* OutLocation, struct FVector* OutFrontDir, struct FVector* OutRightDir) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetAudioListenerPositionCS");

	Params::BGPPlayerController_GetAudioListenerPositionCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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


// Function b1.BGPPlayerController.GetAudioListenerRotationCS
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator*                        OutRotation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABGPPlayerController::GetAudioListenerRotationCS(struct FRotator* OutRotation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetAudioListenerRotationCS");

	Params::BGPPlayerController_GetAudioListenerRotationCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function b1.BGPPlayerController.GetPlayerViewPointCS
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector*                         out_Location                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        out_Rotation                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGPPlayerController::GetPlayerViewPointCS(struct FVector* out_Location, struct FRotator* out_Rotation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerController", "GetPlayerViewPointCS");

	Params::BGPPlayerController_GetPlayerViewPointCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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

	return Parms.ReturnValue;
}


// Function b1.BGPPlayerReverseReplicator.SetOwnerBGUChr
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABGUCharacter*                    BGUOwner                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGPPlayerReverseReplicator::SetOwnerBGUChr(class ABGUCharacter* BGUOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerReverseReplicator", "SetOwnerBGUChr");

	Params::BGPPlayerReverseReplicator_SetOwnerBGUChr Parms{};

	Parms.BGUOwner = BGUOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGPPlayerState.BeginPlayCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerState::BeginPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerState", "BeginPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGPPlayerState.PostInitializeComponentsCS
// (Event, Public, BlueprintEvent)

void ABGPPlayerState::PostInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGPPlayerState", "PostInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUActorBase.ApplyWorldOffsetCS
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   InOffset                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWorldShift                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUActorBase::ApplyWorldOffsetCS(const struct FVector& InOffset, bool bWorldShift)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "ApplyWorldOffsetCS");

	Params::BGUActorBase_ApplyWorldOffsetCS Parms{};

	Parms.InOffset = std::move(InOffset);
	Parms.bWorldShift = bWorldShift;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUActorBase.AttachBaseActorComp
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UBaseActorComp*                   Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUActorBase::AttachBaseActorComp(class UBaseActorComp* Comp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "AttachBaseActorComp");

	Params::BGUActorBase_AttachBaseActorComp Parms{};

	Parms.Comp = Comp;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUActorBase.BeginPlayCS
// (Event, Protected, BlueprintEvent)

void ABGUActorBase::BeginPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "BeginPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUActorBase.ExcuteAndClearAnimNotifyLogicDelayExecuteList
// (Native, Event, Public, BlueprintEvent)

void ABGUActorBase::ExcuteAndClearAnimNotifyLogicDelayExecuteList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "ExcuteAndClearAnimNotifyLogicDelayExecuteList");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUActorBase.ForceRefreshDetailView
// (Final, Native, Protected, BlueprintCallable)

void ABGUActorBase::ForceRefreshDetailView()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "ForceRefreshDetailView");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUActorBase.FullyInit
// (Final, Native, Public, BlueprintCallable)

void ABGUActorBase::FullyInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "FullyInit");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUActorBase.GetBUSEventCollection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBUS_EventCollection*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBUS_EventCollection* ABGUActorBase::GetBUSEventCollection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "GetBUSEventCollection");

	Params::BGUActorBase_GetBUSEventCollection Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUActorBase.OnConstructionCS
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABGUActorBase::OnConstructionCS(const struct FTransform& Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "OnConstructionCS");

	Params::BGUActorBase_OnConstructionCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUActorBase.OnPostEditMove
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bFinish                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUActorBase::OnPostEditMove(bool bFinish)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "OnPostEditMove");

	Params::BGUActorBase_OnPostEditMove Parms{};

	Parms.bFinish = bFinish;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUActorBase.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUActorBase::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "OnPropertyChanged");

	Params::BGUActorBase_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUActorBase.PostInitializeComponentsCS
// (Event, Protected, BlueprintEvent)

void ABGUActorBase::PostInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "PostInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUActorBase.SetCompCanEverAffectNavigation
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UActorComponent*                  ActorComponent                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRelevant                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUActorBase::SetCompCanEverAffectNavigation(class UActorComponent* ActorComponent, bool bRelevant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "SetCompCanEverAffectNavigation");

	Params::BGUActorBase_SetCompCanEverAffectNavigation Parms{};

	Parms.ActorComponent = ActorComponent;
	Parms.bRelevant = bRelevant;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUActorBase.SetRootComponentCS
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class USceneComponent*                  NewRootComponent                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUActorBase::SetRootComponentCS(class USceneComponent* NewRootComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "SetRootComponentCS");

	Params::BGUActorBase_SetRootComponentCS Parms{};

	Parms.NewRootComponent = NewRootComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUActorBase.SetTeamID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUActorBase::SetTeamID(int32 ID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "SetTeamID");

	Params::BGUActorBase_SetTeamID Parms{};

	Parms.ID = ID;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUActorBase.GetActorGuid
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          OutActorGuid                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUActorBase::GetActorGuid(class FString* OutActorGuid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "GetActorGuid");

	Params::BGUActorBase_GetActorGuid Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUActorBase.GetActorGuidCS
// (Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class FString*                          OutActorGuid                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUActorBase::GetActorGuidCS(class FString* OutActorGuid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "GetActorGuidCS");

	Params::BGUActorBase_GetActorGuidCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

	return Parms.ReturnValue;
}


// Function b1.BGUActorBase.GetTeamID
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABGUActorBase::GetTeamID() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "GetTeamID");

	Params::BGUActorBase_GetTeamID Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUActorBase.GetTeamIDCS
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABGUActorBase::GetTeamIDCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUActorBase", "GetTeamIDCS");

	Params::BGUActorBase_GetTeamIDCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGUActorI.ExcuteAndClearAnimNotifyLogicDelayExecuteList
// (Native, Event, Public, BlueprintEvent)

void IBGUActorI::ExcuteAndClearAnimNotifyLogicDelayExecuteList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BGUActorI", "ExcuteAndClearAnimNotifyLogicDelayExecuteList");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUAnimationSyncComponent.OnBeginSyncAnimationOnGuest
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     InGuestMontage                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             InTargetSyncPointOnHost                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             InSelfSyncPointOnGuest                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnableDebugDraw                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NotifyBeginTime                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           DummyMesh                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InGuestActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InBlendInTime                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PlayRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIgnoreSceneCollision                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUAnimationSyncComponent::OnBeginSyncAnimationOnGuest(class UAnimMontage* InGuestMontage, class FName InTargetSyncPointOnHost, class FName InSelfSyncPointOnGuest, bool bEnableDebugDraw, float NotifyBeginTime, class USkeletalMeshComponent* DummyMesh, class AActor* InGuestActor, float InBlendInTime, float PlayRate, bool bIgnoreSceneCollision)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUAnimationSyncComponent", "OnBeginSyncAnimationOnGuest");

	Params::BGUAnimationSyncComponent_OnBeginSyncAnimationOnGuest Parms{};

	Parms.InGuestMontage = InGuestMontage;
	Parms.InTargetSyncPointOnHost = InTargetSyncPointOnHost;
	Parms.InSelfSyncPointOnGuest = InSelfSyncPointOnGuest;
	Parms.bEnableDebugDraw = bEnableDebugDraw;
	Parms.NotifyBeginTime = NotifyBeginTime;
	Parms.DummyMesh = DummyMesh;
	Parms.InGuestActor = InGuestActor;
	Parms.InBlendInTime = InBlendInTime;
	Parms.PlayRate = PlayRate;
	Parms.bIgnoreSceneCollision = bIgnoreSceneCollision;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUAnimationSyncComponent.OnEndSyncAnimationOnGuest
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bStopGuestMontage                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUAnimationSyncComponent::OnEndSyncAnimationOnGuest(bool bStopGuestMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUAnimationSyncComponent", "OnEndSyncAnimationOnGuest");

	Params::BGUAnimationSyncComponent_OnEndSyncAnimationOnGuest Parms{};

	Parms.bStopGuestMontage = bStopGuestMontage;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUAnimationSyncComponent.OnRespectCollisionInASS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bRespect                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUAnimationSyncComponent::OnRespectCollisionInASS(bool bRespect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUAnimationSyncComponent", "OnRespectCollisionInASS");

	Params::BGUAnimationSyncComponent_OnRespectCollisionInASS Parms{};

	Parms.bRespect = bRespect;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUAnimationSyncComponent.OnSwitchSyncGuestTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           NewGuest                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUAnimationSyncComponent::OnSwitchSyncGuestTarget(class AActor* NewGuest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUAnimationSyncComponent", "OnSwitchSyncGuestTarget");

	Params::BGUAnimationSyncComponent_OnSwitchSyncGuestTarget Parms{};

	Parms.NewGuest = NewGuest;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUBounceCheckObject.BindBounceEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UProjectileMovementComponent*     ProjectileMovementComp                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUBounceCheckObject::BindBounceEvent(class UProjectileMovementComponent* ProjectileMovementComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUBounceCheckObject", "BindBounceEvent");

	Params::BGUBounceCheckObject_BindBounceEvent Parms{};

	Parms.ProjectileMovementComp = ProjectileMovementComp;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUBounceCheckObject.OnBounceCheck
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   OldVelocity                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUBounceCheckObject::OnBounceCheck(const struct FHitResult& Hit, const struct FVector& OldVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUBounceCheckObject", "OnBounceCheck");

	Params::BGUBounceCheckObject_OnBounceCheck Parms{};

	Parms.Hit = std::move(Hit);
	Parms.OldVelocity = std::move(OldVelocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.AttachBaseActorComp
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UBaseActorComp*                   Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::AttachBaseActorComp(class UBaseActorComp* Comp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "AttachBaseActorComp");

	Params::BGUCharacter_AttachBaseActorComp Parms{};

	Parms.Comp = Comp;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.CallPostNetInit
// (Final, Native, Public, BlueprintCallable)

void ABGUCharacter::CallPostNetInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "CallPostNetInit");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.ExcuteAndClearAnimNotifyLogicDelayExecuteList
// (Native, Event, Public, BlueprintEvent)

void ABGUCharacter::ExcuteAndClearAnimNotifyLogicDelayExecuteList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "ExcuteAndClearAnimNotifyLogicDelayExecuteList");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.ForceSpawnDefaultControllerCS
// (Final, Native, Public, BlueprintCallable)

void ABGUCharacter::ForceSpawnDefaultControllerCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "ForceSpawnDefaultControllerCS");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.FullyInit
// (Final, Native, Public, BlueprintCallable)

void ABGUCharacter::FullyInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "FullyInit");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.GetBUSEventCollection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBUS_EventCollection*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBUS_EventCollection* ABGUCharacter::GetBUSEventCollection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetBUSEventCollection");

	Params::BGUCharacter_GetBUSEventCollection Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GetGSAuthorityPlayerCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APlayerController* ABGUCharacter::GetGSAuthorityPlayerCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetGSAuthorityPlayerCS");

	Params::BGUCharacter_GetGSAuthorityPlayerCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GetHostSyncMontageSyncStartTime
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABGUCharacter::GetHostSyncMontageSyncStartTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetHostSyncMontageSyncStartTime");

	Params::BGUCharacter_GetHostSyncMontageSyncStartTime Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GSSwapNetRoleCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    HasAuthority_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::GSSwapNetRoleCS(bool HasAuthority_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GSSwapNetRoleCS");

	Params::BGUCharacter_GSSwapNetRoleCS Parms{};

	Parms.HasAuthority_0 = HasAuthority_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.IsInGuestSyncMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUCharacter::IsInGuestSyncMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "IsInGuestSyncMontage");

	Params::BGUCharacter_IsInGuestSyncMontage Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.IsPlayerCharacterCS
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUCharacter::IsPlayerCharacterCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "IsPlayerCharacterCS");

	Params::BGUCharacter_IsPlayerCharacterCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.LeaveGuestSyncMontage
// (Final, Native, Public, BlueprintCallable)

void ABGUCharacter::LeaveGuestSyncMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "LeaveGuestSyncMontage");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.OnActorChannelOpen
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UNetConnection*                   Connection                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::OnActorChannelOpen(class UNetConnection* Connection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnActorChannelOpen");

	Params::BGUCharacter_OnActorChannelOpen Parms{};

	Parms.Connection = Connection;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUCharacter.OnConstructionCS
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABGUCharacter::OnConstructionCS(const struct FTransform& Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnConstructionCS");

	Params::BGUCharacter_OnConstructionCS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUCharacter.OnGuestSyncMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     _HostSyncMontage                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   _HostSyncMontageStartTime                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::OnGuestSyncMontage(class UAnimMontage* _HostSyncMontage, float _HostSyncMontageStartTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnGuestSyncMontage");

	Params::BGUCharacter_OnGuestSyncMontage Parms{};

	Parms._HostSyncMontage = _HostSyncMontage;
	Parms._HostSyncMontageStartTime = _HostSyncMontageStartTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.OnMovementModeChangedCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// EMovementMode                           PrevMovementMode                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMovementMode                           NewMovementMode                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   PrevCustomMode                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   NewCustomMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::OnMovementModeChangedCS(EMovementMode PrevMovementMode, EMovementMode NewMovementMode, uint8 PrevCustomMode, uint8 NewCustomMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnMovementModeChangedCS");

	Params::BGUCharacter_OnMovementModeChangedCS Parms{};

	Parms.PrevMovementMode = PrevMovementMode;
	Parms.NewMovementMode = NewMovementMode;
	Parms.PrevCustomMode = PrevCustomMode;
	Parms.NewCustomMode = NewCustomMode;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUCharacter.OnPlayOrStopNewMontage_FromNotify
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   OldMontageInstID                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::OnPlayOrStopNewMontage_FromNotify(int32 OldMontageInstID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnPlayOrStopNewMontage_FromNotify");

	Params::BGUCharacter_OnPlayOrStopNewMontage_FromNotify Parms{};

	Parms.OldMontageInstID = OldMontageInstID;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.OnPossessedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AController*                      NewController                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::OnPossessedCS(class AController* NewController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnPossessedCS");

	Params::BGUCharacter_OnPossessedCS Parms{};

	Parms.NewController = NewController;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUCharacter.OnRep_PlayerStateCS
// (Event, Public, BlueprintEvent)

void ABGUCharacter::OnRep_PlayerStateCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnRep_PlayerStateCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUCharacter.OnRep_ReplicatedAcceleration
// (Final, Native, Protected)

void ABGUCharacter::OnRep_ReplicatedAcceleration()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnRep_ReplicatedAcceleration");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.OnSetMontageJumpSection_FromNotify
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   MontageInstID                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::OnSetMontageJumpSection_FromNotify(int32 MontageInstID, class FName SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnSetMontageJumpSection_FromNotify");

	Params::BGUCharacter_OnSetMontageJumpSection_FromNotify Parms{};

	Parms.MontageInstID = MontageInstID;
	Parms.SectionName = SectionName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.OnSetMontageNextSection_FromNotify
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   MontageInstID                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::OnSetMontageNextSection_FromNotify(int32 MontageInstID, class FName SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "OnSetMontageNextSection_FromNotify");

	Params::BGUCharacter_OnSetMontageNextSection_FromNotify Parms{};

	Parms.MontageInstID = MontageInstID;
	Parms.SectionName = SectionName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.PostInitializeComponentsCS
// (Event, Protected, BlueprintEvent)

void ABGUCharacter::PostInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "PostInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUCharacter.PostNetReceiveRoleCS
// (Event, Public, BlueprintEvent)

void ABGUCharacter::PostNetReceiveRoleCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "PostNetReceiveRoleCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUCharacter.PreDestroyFromReplicationCS
// (Event, Protected, BlueprintEvent)

void ABGUCharacter::PreDestroyFromReplicationCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "PreDestroyFromReplicationCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUCharacter.SetPreferActorRotToControlRot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::SetPreferActorRotToControlRot(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "SetPreferActorRotToControlRot");

	Params::BGUCharacter_SetPreferActorRotToControlRot Parms{};

	Parms.bValue = bValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.SetTamerOwner
// (Native, Public, BlueprintCallable)
// Parameters:
// class ABGUTamerBase*                    NewOwner                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::SetTamerOwner(class ABGUTamerBase* NewOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "SetTamerOwner");

	Params::BGUCharacter_SetTamerOwner Parms{};

	Parms.NewOwner = NewOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.SetTeamID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::SetTeamID(int32 ID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "SetTeamID");

	Params::BGUCharacter_SetTeamID Parms{};

	Parms.ID = ID;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.SetupPlayerInputComponentCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UInputComponent*                  PlayerInputComponent                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::SetupPlayerInputComponentCS(class UInputComponent* PlayerInputComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "SetupPlayerInputComponentCS");

	Params::BGUCharacter_SetupPlayerInputComponentCS Parms{};

	Parms.PlayerInputComponent = PlayerInputComponent;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUCharacter.SetViewRotationYawOffset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewOffset                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::SetViewRotationYawOffset(float NewOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "SetViewRotationYawOffset");

	Params::BGUCharacter_SetViewRotationYawOffset Parms{};

	Parms.NewOffset = NewOffset;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.SwitchNetRoleOnly
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    HasAuthority_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUCharacter::SwitchNetRoleOnly(bool HasAuthority_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "SwitchNetRoleOnly");

	Params::BGUCharacter_SwitchNetRoleOnly Parms{};

	Parms.HasAuthority_0 = HasAuthority_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacter.TryGetComponentByName
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      CompName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UActorComponent* ABGUCharacter::TryGetComponentByName(const class FName& CompName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "TryGetComponentByName");

	Params::BGUCharacter_TryGetComponentByName Parms{};

	Parms.CompName = CompName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.TryGetHostSyncMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* ABGUCharacter::TryGetHostSyncMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "TryGetHostSyncMontage");

	Params::BGUCharacter_TryGetHostSyncMontage Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GetActorGuid
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          OutActorGuid                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUCharacter::GetActorGuid(class FString* OutActorGuid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetActorGuid");

	Params::BGUCharacter_GetActorGuid Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GetActorGuidCS
// (Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class FString*                          OutActorGuid                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUCharacter::GetActorGuidCS(class FString* OutActorGuid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetActorGuidCS");

	Params::BGUCharacter_GetActorGuidCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GetTamerOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABGUTamerBase*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABGUTamerBase* ABGUCharacter::GetTamerOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetTamerOwner");

	Params::BGUCharacter_GetTamerOwner Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GetTeamID
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABGUCharacter::GetTeamID() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetTeamID");

	Params::BGUCharacter_GetTeamID Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacter.GetViewRotationYawOffset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABGUCharacter::GetViewRotationYawOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacter", "GetViewRotationYawOffset");

	Params::BGUCharacter_GetViewRotationYawOffset Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.AddOrModifyHitMoveCollision
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UShapeComponent*                  ShapeComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EHitMoveDir                       HitMoveDir                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::AddOrModifyHitMoveCollision(class UShapeComponent* ShapeComp, const EHitMoveDir HitMoveDir, bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "AddOrModifyHitMoveCollision");

	Params::BGUCharacterMovementComponent_AddOrModifyHitMoveCollision Parms{};

	Parms.ShapeComp = ShapeComp;
	Parms.HitMoveDir = HitMoveDir;
	Parms.IsEnabled = IsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.CanGetNormalAndSurfaceTypeInfoFromMovement
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUCharacterMovementComponent::CanGetNormalAndSurfaceTypeInfoFromMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "CanGetNormalAndSurfaceTypeInfoFromMovement");

	Params::BGUCharacterMovementComponent_CanGetNormalAndSurfaceTypeInfoFromMovement Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.ClearHitMoveCollisions
// (Final, Native, Public, BlueprintCallable)

void UBGUCharacterMovementComponent::ClearHitMoveCollisions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "ClearHitMoveCollisions");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.ClearTopZInFalling
// (Final, Native, Public, BlueprintCallable)

void UBGUCharacterMovementComponent::ClearTopZInFalling()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "ClearTopZInFalling");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.CustomJumpMoveBreak
// (Final, Native, Public, BlueprintCallable)

void UBGUCharacterMovementComponent::CustomJumpMoveBreak()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "CustomJumpMoveBreak");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.GetHitMoveCollisionIsEnabled
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UShapeComponent*                  ShapeComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsEnabled                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUCharacterMovementComponent::GetHitMoveCollisionIsEnabled(class UShapeComponent* ShapeComp, bool* IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "GetHitMoveCollisionIsEnabled");

	Params::BGUCharacterMovementComponent_GetHitMoveCollisionIsEnabled Parms{};

	Parms.ShapeComp = ShapeComp;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.GetTopZInFalling
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUCharacterMovementComponent::GetTopZInFalling()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "GetTopZInFalling");

	Params::BGUCharacterMovementComponent_GetTopZInFalling Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.HasAnimRootMotion_CS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUCharacterMovementComponent::HasAnimRootMotion_CS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "HasAnimRootMotion_CS");

	Params::BGUCharacterMovementComponent_HasAnimRootMotion_CS Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.HitMoveUpdate
// (Final, Native, Public, BlueprintCallable)

void UBGUCharacterMovementComponent::HitMoveUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "HitMoveUpdate");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.IsUseSeparateBrakingFriction
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUCharacterMovementComponent::IsUseSeparateBrakingFriction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "IsUseSeparateBrakingFriction");

	Params::BGUCharacterMovementComponent_IsUseSeparateBrakingFriction Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.LaunchVelocityZ
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   VelocityZ                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::LaunchVelocityZ(float VelocityZ)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "LaunchVelocityZ");

	Params::BGUCharacterMovementComponent_LaunchVelocityZ Parms{};

	Parms.VelocityZ = VelocityZ;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.MoveUpdateHitMove
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::MoveUpdateHitMove(const struct FVector& Delta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "MoveUpdateHitMove");

	Params::BGUCharacterMovementComponent_MoveUpdateHitMove Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.ResetGravityToNormalGravity
// (Final, Native, Public, BlueprintCallable)

void UBGUCharacterMovementComponent::ResetGravityToNormalGravity()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "ResetGravityToNormalGravity");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetCustomJumpVelocityIncrement
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   VelocityIncrement                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetCustomJumpVelocityIncrement(float VelocityIncrement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetCustomJumpVelocityIncrement");

	Params::BGUCharacterMovementComponent_SetCustomJumpVelocityIncrement Parms{};

	Parms.VelocityIncrement = VelocityIncrement;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetDisableNavWalkOptByWhiteList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bDisable                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetDisableNavWalkOptByWhiteList(bool bDisable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetDisableNavWalkOptByWhiteList");

	Params::BGUCharacterMovementComponent_SetDisableNavWalkOptByWhiteList Parms{};

	Parms.bDisable = bDisable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetEnableSimplePhysWalkCollision
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetEnableSimplePhysWalkCollision(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetEnableSimplePhysWalkCollision");

	Params::BGUCharacterMovementComponent_SetEnableSimplePhysWalkCollision Parms{};

	Parms.bEnable = bEnable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetGravityToJumpOffGravity
// (Final, Native, Public, BlueprintCallable)

void UBGUCharacterMovementComponent::SetGravityToJumpOffGravity()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetGravityToJumpOffGravity");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetHitMoveCollisionDirection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UShapeComponent*                  ShapeComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EHitMoveDir                             HitMoveDir                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetHitMoveCollisionDirection(class UShapeComponent* ShapeComp, EHitMoveDir HitMoveDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetHitMoveCollisionDirection");

	Params::BGUCharacterMovementComponent_SetHitMoveCollisionDirection Parms{};

	Parms.ShapeComp = ShapeComp;
	Parms.HitMoveDir = HitMoveDir;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetHitMoveCollisionEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UShapeComponent*                  ShapeComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetHitMoveCollisionEnabled(class UShapeComponent* ShapeComp, bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetHitMoveCollisionEnabled");

	Params::BGUCharacterMovementComponent_SetHitMoveCollisionEnabled Parms{};

	Parms.ShapeComp = ShapeComp;
	Parms.IsEnabled = IsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetHitMoveIgnoredActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    RemoveIgnoredActor                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetHitMoveIgnoredActor(class AActor* Actor, bool RemoveIgnoredActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetHitMoveIgnoredActor");

	Params::BGUCharacterMovementComponent_SetHitMoveIgnoredActor Parms{};

	Parms.Actor = Actor;
	Parms.RemoveIgnoredActor = RemoveIgnoredActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetNavWalkOptLevel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   NewLevel                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetNavWalkOptLevel(int32 NewLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetNavWalkOptLevel");

	Params::BGUCharacterMovementComponent_SetNavWalkOptLevel Parms{};

	Parms.NewLevel = NewLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetNavWalkOptMassiveMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bMassiveOpt                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetNavWalkOptMassiveMode(bool bMassiveOpt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetNavWalkOptMassiveMode");

	Params::BGUCharacterMovementComponent_SetNavWalkOptMassiveMode Parms{};

	Parms.bMassiveOpt = bMassiveOpt;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetOnMovingPlatform
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsOnMovingPlatform                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetOnMovingPlatform(bool bIsOnMovingPlatform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetOnMovingPlatform");

	Params::BGUCharacterMovementComponent_SetOnMovingPlatform Parms{};

	Parms.bIsOnMovingPlatform = bIsOnMovingPlatform;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetSwitchToNavWalkCumulateTime
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetSwitchToNavWalkCumulateTime(float Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetSwitchToNavWalkCumulateTime");

	Params::BGUCharacterMovementComponent_SetSwitchToNavWalkCumulateTime Parms{};

	Parms.Time = Time;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetUseSeparateBrakingFriction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUse                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetUseSeparateBrakingFriction(bool bUse)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetUseSeparateBrakingFriction");

	Params::BGUCharacterMovementComponent_SetUseSeparateBrakingFriction Parms{};

	Parms.bUse = bUse;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.TryGetCurHitPointFromMovement
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UBGUCharacterMovementComponent::TryGetCurHitPointFromMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "TryGetCurHitPointFromMovement");

	Params::BGUCharacterMovementComponent_TryGetCurHitPointFromMovement Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.TryGetCurNormalFromMovement
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UBGUCharacterMovementComponent::TryGetCurNormalFromMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "TryGetCurNormalFromMovement");

	Params::BGUCharacterMovementComponent_TryGetCurNormalFromMovement Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.TryGetCurSurfaceTypeFromMovement
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUCharacterMovementComponent::TryGetCurSurfaceTypeFromMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "TryGetCurSurfaceTypeFromMovement");

	Params::BGUCharacterMovementComponent_TryGetCurSurfaceTypeFromMovement Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.IsInJumpOffAdjust
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUCharacterMovementComponent::IsInJumpOffAdjust() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "IsInJumpOffAdjust");

	Params::BGUCharacterMovementComponent_IsInJumpOffAdjust Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.IsInNavWalkOptMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUCharacterMovementComponent::IsInNavWalkOptMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "IsInNavWalkOptMode");

	Params::BGUCharacterMovementComponent_IsInNavWalkOptMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.IsWalkOnDitch
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUCharacterMovementComponent::IsWalkOnDitch() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "IsWalkOnDitch");

	Params::BGUCharacterMovementComponent_IsWalkOnDitch Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUCharacterMovementComponent.SetJumpOffState
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// bool                                    JumpOff                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetJumpOffState(bool JumpOff) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetJumpOffState");

	Params::BGUCharacterMovementComponent_SetJumpOffState Parms{};

	Parms.JumpOff = JumpOff;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUCharacterMovementComponent.SetWalkOnDitch
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// bool                                    bDitch                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUCharacterMovementComponent::SetWalkOnDitch(bool bDitch) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUCharacterMovementComponent", "SetWalkOnDitch");

	Params::BGUCharacterMovementComponent_SetWalkOnDitch Parms{};

	Parms.bDitch = bDitch;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSSystem.CSGetDataByClass
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UBaseActorComp*                   Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           Cls                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UBGUFuncLibCSSystem::CSGetDataByClass(class UBaseActorComp* Comp, class UClass* Cls)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSSystem", "CSGetDataByClass");

	Params::BGUFuncLibCSSystem_CSGetDataByClass Parms{};

	Parms.Comp = Comp;
	Parms.Cls = Cls;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibCSSystem.CSGetReadOnlyData
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           OwnerActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           Cls                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UBGUFuncLibCSSystem::CSGetReadOnlyData(class AActor* OwnerActor, class UClass* Cls)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSSystem", "CSGetReadOnlyData");

	Params::BGUFuncLibCSSystem_CSGetReadOnlyData Parms{};

	Parms.OwnerActor = OwnerActor;
	Parms.Cls = Cls;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.AddLevelStreaming
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bShouldBlockOnLoad                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UBGUFunctionLibrary::AddLevelStreaming(class UObject* WorldContextObject, const class FName& LevelName, const struct FVector& Location, const struct FRotator& Rotation, bool bShouldBlockOnLoad)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "AddLevelStreaming");

	Params::BGUFunctionLibrary_AddLevelStreaming Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.bShouldBlockOnLoad = bShouldBlockOnLoad;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.ApplyLevelTransform
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                LevelTransform                                         (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::ApplyLevelTransform(class UObject* WorldContextObject, const class FName& LevelName, const struct FTransform& LevelTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "ApplyLevelTransform");

	Params::BGUFunctionLibrary_ApplyLevelTransform Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;
	Parms.LevelTransform = std::move(LevelTransform);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUActorUpdateAllTFXComp
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUActorUpdateAllTFXComp(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUActorUpdateAllTFXComp");

	Params::BGUFunctionLibrary_BGUActorUpdateAllTFXComp Parms{};

	Parms.Actor = Actor;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUBeginDeferredActorSpawnFromClass
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AActor>               ActorClass                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                SpawnTransform                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// ESpawnActorCollisionHandlingMethod      CollisionHandlingOverride                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Owner                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UBGUFunctionLibrary::BGUBeginDeferredActorSpawnFromClass(const class UObject* WorldContextObject, TSubclassOf<class AActor> ActorClass, const struct FTransform& SpawnTransform, ESpawnActorCollisionHandlingMethod CollisionHandlingOverride, class AActor* Owner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUBeginDeferredActorSpawnFromClass");

	Params::BGUFunctionLibrary_BGUBeginDeferredActorSpawnFromClass Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActorClass = ActorClass;
	Parms.SpawnTransform = std::move(SpawnTransform);
	Parms.CollisionHandlingOverride = CollisionHandlingOverride;
	Parms.Owner = Owner;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUBeginDeferredActorSpawnFromClassWithName
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AActor>               ActorClass                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                SpawnTransform                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// ESpawnActorCollisionHandlingMethod      CollisionHandlingOverride                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Owner                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ActorName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULevel*                           OverrideLevel                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UBGUFunctionLibrary::BGUBeginDeferredActorSpawnFromClassWithName(const class UObject* WorldContextObject, TSubclassOf<class AActor> ActorClass, const struct FTransform& SpawnTransform, ESpawnActorCollisionHandlingMethod CollisionHandlingOverride, class AActor* Owner, class FName ActorName, class ULevel* OverrideLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUBeginDeferredActorSpawnFromClassWithName");

	Params::BGUFunctionLibrary_BGUBeginDeferredActorSpawnFromClassWithName Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActorClass = ActorClass;
	Parms.SpawnTransform = std::move(SpawnTransform);
	Parms.CollisionHandlingOverride = CollisionHandlingOverride;
	Parms.Owner = Owner;
	Parms.ActorName = ActorName;
	Parms.OverrideLevel = OverrideLevel;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUCalcBounds
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              StaticMesh                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         Origin                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         BoxExtent                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  SphereRadius                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUCalcBounds(class UPrimitiveComponent* StaticMesh, struct FVector* Origin, struct FVector* BoxExtent, float* SphereRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUCalcBounds");

	Params::BGUFunctionLibrary_BGUCalcBounds Parms{};

	Parms.StaticMesh = StaticMesh;

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

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

	Func->FunctionFlags = Flgs;

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

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

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


// Function b1.BGUFunctionLibrary.BGUFindFirstActorWithTag
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TagName                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UBGUFunctionLibrary::BGUFindFirstActorWithTag(const class UObject* WorldContextObject, class FName TagName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUFindFirstActorWithTag");

	Params::BGUFunctionLibrary_BGUFindFirstActorWithTag Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TagName = TagName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUFinishSpawningActor
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                SpawnTransform                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UBGUFunctionLibrary::BGUFinishSpawningActor(class AActor* Actor, const struct FTransform& SpawnTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUFinishSpawningActor");

	Params::BGUFunctionLibrary_BGUFinishSpawningActor Parms{};

	Parms.Actor = Actor;
	Parms.SpawnTransform = std::move(SpawnTransform);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUFlushLevelStreamingOnlyVisibility
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUFlushLevelStreamingOnlyVisibility(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUFlushLevelStreamingOnlyVisibility");

	Params::BGUFunctionLibrary_BGUFlushLevelStreamingOnlyVisibility Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUGenComponent
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UActorComponent>      ActorComponentClass                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UActorComponent* UBGUFunctionLibrary::BGUGenComponent(class AActor* Actor, TSubclassOf<class UActorComponent> ActorComponentClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGenComponent");

	Params::BGUFunctionLibrary_BGUGenComponent Parms{};

	Parms.Actor = Actor;
	Parms.ActorComponentClass = ActorComponentClass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGenComponentAndAdd
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UActorComponent>      ActorComponentClass                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UActorComponent* UBGUFunctionLibrary::BGUGenComponentAndAdd(class AActor* Actor, TSubclassOf<class UActorComponent> ActorComponentClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGenComponentAndAdd");

	Params::BGUFunctionLibrary_BGUGenComponentAndAdd Parms{};

	Parms.Actor = Actor;
	Parms.ActorComponentClass = ActorComponentClass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGenProceduralLevel
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      WorldAssetName                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InLevelName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                InLevelTransform                                       (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class ULevelStreaming*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULevelStreaming* UBGUFunctionLibrary::BGUGenProceduralLevel(class UObject* WorldContextObject, const class FName& WorldAssetName, const class FName& InLevelName, const struct FTransform& InLevelTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGenProceduralLevel");

	Params::BGUFunctionLibrary_BGUGenProceduralLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.WorldAssetName = WorldAssetName;
	Parms.InLevelName = InLevelName;
	Parms.InLevelTransform = std::move(InLevelTransform);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetActiveMontagePosition
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class ABGUCharacter*              Actor                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibrary::BGUGetActiveMontagePosition(const class ABGUCharacter* Actor, const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetActiveMontagePosition");

	Params::BGUFunctionLibrary_BGUGetActiveMontagePosition Parms{};

	Parms.Actor = Actor;
	Parms.Montage = Montage;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetAllActorsWithTagInRangeSorted
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           CenterActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TagName                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Range                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  OutActors                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUGetAllActorsWithTagInRangeSorted(class AActor* CenterActor, class FName TagName, int32 Range, TArray<class AActor*>* OutActors)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetAllActorsWithTagInRangeSorted");

	Params::BGUFunctionLibrary_BGUGetAllActorsWithTagInRangeSorted Parms{};

	Parms.CenterActor = CenterActor;
	Parms.TagName = TagName;
	Parms.Range = Range;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetHitResultActor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FActorInstanceHandle&      ActorInstanceHandle                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UBGUFunctionLibrary::BGUGetHitResultActor(const struct FActorInstanceHandle& ActorInstanceHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetHitResultActor");

	Params::BGUFunctionLibrary_BGUGetHitResultActor Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetMontageSectionLengthByIndex
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibrary::BGUGetMontageSectionLengthByIndex(class AActor* Unit, class UAnimMontage* AnimMontage, int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetMontageSectionLengthByIndex");

	Params::BGUFunctionLibrary_BGUGetMontageSectionLengthByIndex Parms{};

	Parms.Unit = Unit;
	Parms.AnimMontage = AnimMontage;
	Parms.Index_0 = Index_0;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetMontageSectionLengthByName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibrary::BGUGetMontageSectionLengthByName(class AActor* Unit, class UAnimMontage* AnimMontage, class FName SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetMontageSectionLengthByName");

	Params::BGUFunctionLibrary_BGUGetMontageSectionLengthByName Parms{};

	Parms.Unit = Unit;
	Parms.AnimMontage = AnimMontage;
	Parms.SectionName = SectionName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetMontageSectionStartAndEndTime
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutStartTime                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutEndTime                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUGetMontageSectionStartAndEndTime(class UAnimMontage* AnimMontage, class FName SectionName, float* OutStartTime, float* OutEndTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetMontageSectionStartAndEndTime");

	Params::BGUFunctionLibrary_BGUGetMontageSectionStartAndEndTime Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.SectionName = SectionName;

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

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

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetMontageSectionTimeLeftFromPos
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibrary::BGUGetMontageSectionTimeLeftFromPos(class AActor* Unit, class UAnimMontage* AnimMontage, float position)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetMontageSectionTimeLeftFromPos");

	Params::BGUFunctionLibrary_BGUGetMontageSectionTimeLeftFromPos Parms{};

	Parms.Unit = Unit;
	Parms.AnimMontage = AnimMontage;
	Parms.position = position;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetSkeletalMeshSimulatedBodiesBelowNum
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           SkeletalMesh                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludeSelf                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFunctionLibrary::BGUGetSkeletalMeshSimulatedBodiesBelowNum(class USkeletalMeshComponent* SkeletalMesh, class FName BoneName, bool bIncludeSelf)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetSkeletalMeshSimulatedBodiesBelowNum");

	Params::BGUFunctionLibrary_BGUGetSkeletalMeshSimulatedBodiesBelowNum Parms{};

	Parms.SkeletalMesh = SkeletalMesh;
	Parms.BoneName = BoneName;
	Parms.bIncludeSelf = bIncludeSelf;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetTeamID
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFunctionLibrary::BGUGetTeamID(class AActor* Unit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetTeamID");

	Params::BGUFunctionLibrary_BGUGetTeamID Parms{};

	Parms.Unit = Unit;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUGetWindParameters_GameThread
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         position                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutDirection                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutSpeed                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutMinGustAmt                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutMaxGustAmt                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUGetWindParameters_GameThread(class AActor* WorldContext, struct FVector* position, struct FVector* OutDirection, float* OutSpeed, float* OutMinGustAmt, float* OutMaxGustAmt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUGetWindParameters_GameThread");

	Params::BGUFunctionLibrary_BGUGetWindParameters_GameThread Parms{};

	Parms.WorldContext = WorldContext;

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

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

	Func->FunctionFlags = Flgs;

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

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

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

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

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


// Function b1.BGUFunctionLibrary.BGUHasFuncName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Object                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           StopAtClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUHasFuncName(class FName FuncName, class UObject* Object, class UClass* StopAtClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUHasFuncName");

	Params::BGUFunctionLibrary_BGUHasFuncName Parms{};

	Parms.FuncName = FuncName;
	Parms.Object = Object;
	Parms.StopAtClass = StopAtClass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUIsExistFile
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Path                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUIsExistFile(const class FString& Path)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUIsExistFile");

	Params::BGUFunctionLibrary_BGUIsExistFile Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGULoadStreamLevel
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bMakeVisibleAfterLoad                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldBlockOnLoad                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          CallbackTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      CallbackFunc                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ActionID                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Linkage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGULoadStreamLevel(class UObject* WorldContextObject, const class FName& LevelName, bool bMakeVisibleAfterLoad, bool bShouldBlockOnLoad, class UObject* CallbackTarget, const class FName& CallbackFunc, int32 ActionID, int32 Linkage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGULoadStreamLevel");

	Params::BGUFunctionLibrary_BGULoadStreamLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;
	Parms.bMakeVisibleAfterLoad = bMakeVisibleAfterLoad;
	Parms.bShouldBlockOnLoad = bShouldBlockOnLoad;
	Parms.CallbackTarget = CallbackTarget;
	Parms.CallbackFunc = CallbackFunc;
	Parms.ActionID = ActionID;
	Parms.Linkage = Linkage;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUMergeSkeletalMesh
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class USkeletalMesh*                    InMergeMesh                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class USkeletalMesh*>&     InSrcMeshList                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   StripTopLODS                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMeshBufferAccess                       MeshBufferAccess                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUMergeSkeletalMesh(class USkeletalMesh* InMergeMesh, const TArray<class USkeletalMesh*>& InSrcMeshList, int32 StripTopLODS, EMeshBufferAccess MeshBufferAccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUMergeSkeletalMesh");

	Params::BGUFunctionLibrary_BGUMergeSkeletalMesh Parms{};

	Parms.InMergeMesh = InMergeMesh;
	Parms.InSrcMeshList = std::move(InSrcMeshList);
	Parms.StripTopLODS = StripTopLODS;
	Parms.MeshBufferAccess = MeshBufferAccess;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUNavigationCalPathCost
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   PathStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   PathEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  PathCost                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUNavigationCalPathCost(class UObject* WorldContextObject, const struct FVector& PathStart, const struct FVector& PathEnd, float* PathCost, class AController* Querier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUNavigationCalPathCost");

	Params::BGUFunctionLibrary_BGUNavigationCalPathCost Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PathStart = std::move(PathStart);
	Parms.PathEnd = std::move(PathEnd);
	Parms.Querier = Querier;

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

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

	Func->FunctionFlags = Flgs;

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


// Function b1.BGUFunctionLibrary.BGUNavigationRaycast
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayStart                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayEnd                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         HitLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UNavigationQueryFilter>FilterClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUNavigationRaycast(class UObject* WorldContextObject, const struct FVector& RayStart, const struct FVector& RayEnd, struct FVector* HitLocation, TSubclassOf<class UNavigationQueryFilter> FilterClass, class AController* Querier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUNavigationRaycast");

	Params::BGUFunctionLibrary_BGUNavigationRaycast Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.RayStart = std::move(RayStart);
	Parms.RayEnd = std::move(RayEnd);
	Parms.FilterClass = FilterClass;
	Parms.Querier = Querier;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUPerlinNoise1D
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibrary::BGUPerlinNoise1D(float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUPerlinNoise1D");

	Params::BGUFunctionLibrary_BGUPerlinNoise1D Parms{};

	Parms.Value = Value;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUPlayerCtrlerGetViewPoint
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*                PlayerCtrler                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         out_Location                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        out_Rotation                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUPlayerCtrlerGetViewPoint(class APlayerController* PlayerCtrler, struct FVector* out_Location, struct FRotator* out_Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUPlayerCtrlerGetViewPoint");

	Params::BGUFunctionLibrary_BGUPlayerCtrlerGetViewPoint Parms{};

	Parms.PlayerCtrler = PlayerCtrler;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFunctionLibrary.BGUProcessLatentActions
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          InObject                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUProcessLatentActions(class UObject* WorldContextObject, class UObject* InObject, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUProcessLatentActions");

	Params::BGUFunctionLibrary_BGUProcessLatentActions Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InObject = InObject;
	Parms.DeltaTime = DeltaTime;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUProjectPointToNavigation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Point                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         ProjectedLocation                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ANavigationData*                  NavData                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UNavigationQueryFilter>FilterClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   QueryExtent                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUProjectPointToNavigation(class UObject* WorldContextObject, const struct FVector& Point, struct FVector* ProjectedLocation, class ANavigationData* NavData, TSubclassOf<class UNavigationQueryFilter> FilterClass, const struct FVector& QueryExtent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUProjectPointToNavigation");

	Params::BGUFunctionLibrary_BGUProjectPointToNavigation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Point = std::move(Point);
	Parms.NavData = NavData;
	Parms.FilterClass = FilterClass;
	Parms.QueryExtent = std::move(QueryExtent);

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGURenameActorComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UActorComponent*                  Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    NewName                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGURenameActorComponent(class UActorComponent* Comp, const class FString& NewName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGURenameActorComponent");

	Params::BGUFunctionLibrary_BGURenameActorComponent Parms{};

	Parms.Comp = Comp;
	Parms.NewName = std::move(NewName);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUResetActorVelocity
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUResetActorVelocity(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUResetActorVelocity");

	Params::BGUFunctionLibrary_BGUResetActorVelocity Parms{};

	Parms.Actor = Actor;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUResetGeometryCollectionComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGeometryCollectionComponent*     GeometryCollectionComponent                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUResetGeometryCollectionComponent(class UGeometryCollectionComponent* GeometryCollectionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUResetGeometryCollectionComponent");

	Params::BGUFunctionLibrary_BGUResetGeometryCollectionComponent Parms{};

	Parms.GeometryCollectionComponent = GeometryCollectionComponent;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUResetToDefaultBoomCameraLagSpeed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUResetToDefaultBoomCameraLagSpeed(class AActor* PlayerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUResetToDefaultBoomCameraLagSpeed");

	Params::BGUFunctionLibrary_BGUResetToDefaultBoomCameraLagSpeed Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUSaveUnitAttrToFile
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Text                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Overwrite                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUSaveUnitAttrToFile(const class FString& Name_0, const class FString& Text, bool Overwrite)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSaveUnitAttrToFile");

	Params::BGUFunctionLibrary_BGUSaveUnitAttrToFile Parms{};

	Parms.Name_0 = std::move(Name_0);
	Parms.Text = std::move(Text);
	Parms.Overwrite = Overwrite;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUSeparatingAxisPointCheck
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const TArray<struct FVector>&           InPolyVertices                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   InBoxCenter                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InBoxExtent                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInCalcLeastPenetration                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUSeparatingAxisPointCheck(const TArray<struct FVector>& InPolyVertices, const struct FVector& InBoxCenter, const struct FVector& InBoxExtent, bool bInCalcLeastPenetration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSeparatingAxisPointCheck");

	Params::BGUFunctionLibrary_BGUSeparatingAxisPointCheck Parms{};

	Parms.InPolyVertices = std::move(InPolyVertices);
	Parms.InBoxCenter = std::move(InBoxCenter);
	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bInCalcLeastPenetration = bInCalcLeastPenetration;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUSetActiveMontagePosition
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class ABGUCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             position                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUSetActiveMontagePosition(const class ABGUCharacter* Character, const class UAnimMontage* Montage, const float position)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSetActiveMontagePosition");

	Params::BGUFunctionLibrary_BGUSetActiveMontagePosition Parms{};

	Parms.Character = Character;
	Parms.Montage = Montage;
	Parms.position = position;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUSetEnableGravity
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           TargetMesh                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnableGravity                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUSetEnableGravity(class USkeletalMeshComponent* TargetMesh, bool bEnableGravity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSetEnableGravity");

	Params::BGUFunctionLibrary_BGUSetEnableGravity Parms{};

	Parms.TargetMesh = TargetMesh;
	Parms.bEnableGravity = bEnableGravity;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUSetLinearColorParameterValueToMesh
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshInst                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       ParameterName                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LinearColorParameterValue                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUSetLinearColorParameterValueToMesh(class UMeshComponent* MeshInst, const class FName ParameterName, const struct FLinearColor& LinearColorParameterValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSetLinearColorParameterValueToMesh");

	Params::BGUFunctionLibrary_BGUSetLinearColorParameterValueToMesh Parms{};

	Parms.MeshInst = MeshInst;
	Parms.ParameterName = ParameterName;
	Parms.LinearColorParameterValue = std::move(LinearColorParameterValue);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUSetTressFXAssetAndMaterial
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UTressFXComponent*                TFXComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTressFXAsset*                    Asset                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstance*                Material                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUSetTressFXAssetAndMaterial(class UTressFXComponent* TFXComp, class UTressFXAsset* Asset, class UMaterialInstance* Material)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSetTressFXAssetAndMaterial");

	Params::BGUFunctionLibrary_BGUSetTressFXAssetAndMaterial Parms{};

	Parms.TFXComp = TFXComp;
	Parms.Asset = Asset;
	Parms.Material = Material;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUSetValueToCurveFloat
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UCurveFloat*                      CurveFloat                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Key                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ERichCurveInterpMode                    InterpMode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUSetValueToCurveFloat(class UCurveFloat* CurveFloat, float Key, float Value, ERichCurveInterpMode InterpMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSetValueToCurveFloat");

	Params::BGUFunctionLibrary_BGUSetValueToCurveFloat Parms{};

	Parms.CurveFloat = CurveFloat;
	Parms.Key = Key;
	Parms.Value = Value;
	Parms.InterpMode = InterpMode;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUSetValueToCurveVector
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UCurveVector*                     CurveVector                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Key                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ERichCurveInterpMode                    InterpMode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUSetValueToCurveVector(class UCurveVector* CurveVector, float Key, const struct FVector& Value, ERichCurveInterpMode InterpMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSetValueToCurveVector");

	Params::BGUFunctionLibrary_BGUSetValueToCurveVector Parms{};

	Parms.CurveVector = CurveVector;
	Parms.Key = Key;
	Parms.Value = std::move(Value);
	Parms.InterpMode = InterpMode;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUShapeSweepMultiByObjectType
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UShapeComponent*            ShapeComp                                              (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FHitResult>*              OutHits                                                (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bIgnoreSelf                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUShapeSweepMultiByObjectType(const class UShapeComponent* ShapeComp, const struct FVector& Start, const struct FVector& End, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUShapeSweepMultiByObjectType");

	Params::BGUFunctionLibrary_BGUShapeSweepMultiByObjectType Parms{};

	Parms.ShapeComp = ShapeComp;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.bTraceComplex = bTraceComplex;
	Parms.bIgnoreSelf = bIgnoreSelf;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUSKMeshContainSocket
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           SkMeshComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::BGUSKMeshContainSocket(class USkeletalMeshComponent* SkMeshComp, class FName SocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUSKMeshContainSocket");

	Params::BGUFunctionLibrary_BGUSKMeshContainSocket Parms{};

	Parms.SkMeshComp = SkMeshComp;
	Parms.SocketName = SocketName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.BGUUnloadStreamLevel
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldBlockOnUnload                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          CallbackTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      CallbackFunc                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ActionID                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Linkage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUUnloadStreamLevel(class UObject* WorldContextObject, const class FName& LevelName, bool bShouldBlockOnUnload, class UObject* CallbackTarget, const class FName& CallbackFunc, int32 ActionID, int32 Linkage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUUnloadStreamLevel");

	Params::BGUFunctionLibrary_BGUUnloadStreamLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;
	Parms.bShouldBlockOnUnload = bShouldBlockOnUnload;
	Parms.CallbackTarget = CallbackTarget;
	Parms.CallbackFunc = CallbackFunc;
	Parms.ActionID = ActionID;
	Parms.Linkage = Linkage;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUUpdateLevelStreaming
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           CurWorld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUUpdateLevelStreaming(class UWorld* CurWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUUpdateLevelStreaming");

	Params::BGUFunctionLibrary_BGUUpdateLevelStreaming Parms{};

	Parms.CurWorld = CurWorld;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BGUWoodTestCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ScaleRate                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::BGUWoodTestCharacter(class AActor* Character, class UAnimMontage* Montage, float ScaleRate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BGUWoodTestCharacter");

	Params::BGUFunctionLibrary_BGUWoodTestCharacter Parms{};

	Parms.Character = Character;
	Parms.Montage = Montage;
	Parms.ScaleRate = ScaleRate;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.BonesSphereMask
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           TargetSkeletalMesh                                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldPosition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UBGUFunctionLibrary::BonesSphereMask(class USkeletalMeshComponent* TargetSkeletalMesh, float Radius, const struct FVector& WorldPosition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "BonesSphereMask");

	Params::BGUFunctionLibrary_BonesSphereMask Parms{};

	Parms.TargetSkeletalMesh = TargetSkeletalMesh;
	Parms.Radius = Radius;
	Parms.WorldPosition = std::move(WorldPosition);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.CalculateMontageCostValue
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const TArray<class UAnimMontage*>&      MontageList                                            (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<class FName>&              BoneNameList                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::CalculateMontageCostValue(const TArray<class UAnimMontage*>& MontageList, const TArray<class FName>& BoneNameList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "CalculateMontageCostValue");

	Params::BGUFunctionLibrary_CalculateMontageCostValue Parms{};

	Parms.MontageList = std::move(MontageList);
	Parms.BoneNameList = std::move(BoneNameList);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.DrawDebugString
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TextLocation                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Text                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TestBaseActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              TextColor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::DrawDebugString(const class UObject* WorldContextObject, const struct FVector& TextLocation, const class FString& Text, class AActor* TestBaseActor, const struct FLinearColor& TextColor, float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "DrawDebugString");

	Params::BGUFunctionLibrary_DrawDebugString Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TextLocation = std::move(TextLocation);
	Parms.Text = std::move(Text);
	Parms.TestBaseActor = TestBaseActor;
	Parms.TextColor = std::move(TextColor);
	Parms.Duration = Duration;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.ForceLoadTileLOD
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    TileName                                               (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SwitchOn                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::ForceLoadTileLOD(class UObject* WorldContext, const class FString& TileName, int32 SwitchOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "ForceLoadTileLOD");

	Params::BGUFunctionLibrary_ForceLoadTileLOD Parms{};

	Parms.WorldContext = WorldContext;
	Parms.TileName = std::move(TileName);
	Parms.SwitchOn = SwitchOn;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.GetAllActorsInLevel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ULevel*                           Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UBGUFunctionLibrary::GetAllActorsInLevel(class ULevel* Level)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetAllActorsInLevel");

	Params::BGUFunctionLibrary_GetAllActorsInLevel Parms{};

	Parms.Level = Level;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetAllActorsInWorld
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UBGUFunctionLibrary::GetAllActorsInWorld(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetAllActorsInWorld");

	Params::BGUFunctionLibrary_GetAllActorsInWorld Parms{};

	Parms.World = World;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetAllAssetDependencies
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             SelectedPackageName                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UBGUFunctionLibrary::GetAllAssetDependencies(class FName SelectedPackageName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetAllAssetDependencies");

	Params::BGUFunctionLibrary_GetAllAssetDependencies Parms{};

	Parms.SelectedPackageName = SelectedPackageName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetAllAssetReference
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             SelectedPackageName                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UBGUFunctionLibrary::GetAllAssetReference(class FName SelectedPackageName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetAllAssetReference");

	Params::BGUFunctionLibrary_GetAllAssetReference Parms{};

	Parms.SelectedPackageName = SelectedPackageName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetAssetLongPackageName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      ClassName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AssetName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UBGUFunctionLibrary::GetAssetLongPackageName(const class FName& ClassName, const class FString& AssetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetAssetLongPackageName");

	Params::BGUFunctionLibrary_GetAssetLongPackageName Parms{};

	Parms.ClassName = ClassName;
	Parms.AssetName = std::move(AssetName);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetLevelStreaming
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ULevelStreaming*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ULevelStreaming*> UBGUFunctionLibrary::GetLevelStreaming(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetLevelStreaming");

	Params::BGUFunctionLibrary_GetLevelStreaming Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetLevelStreamingFromWorld
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ULevelStreaming*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ULevelStreaming*> UBGUFunctionLibrary::GetLevelStreamingFromWorld(const class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetLevelStreamingFromWorld");

	Params::BGUFunctionLibrary_GetLevelStreamingFromWorld Parms{};

	Parms.World = World;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetLevelStreamingLevelTransformByName
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UBGUFunctionLibrary::GetLevelStreamingLevelTransformByName(class UObject* WorldContextObject, const class FName& LevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetLevelStreamingLevelTransformByName");

	Params::BGUFunctionLibrary_GetLevelStreamingLevelTransformByName Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetLevelStreamingState
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

uint8 UBGUFunctionLibrary::GetLevelStreamingState(class UObject* WorldContextObject, const class FName& LevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetLevelStreamingState");

	Params::BGUFunctionLibrary_GetLevelStreamingState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetNearestBoneName
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           TargetSkeletalMesh                                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldPosition                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            OptionalWhiteList                                      (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UBGUFunctionLibrary::GetNearestBoneName(class USkeletalMeshComponent* TargetSkeletalMesh, const struct FVector& WorldPosition, const TArray<class FString>& OptionalWhiteList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetNearestBoneName");

	Params::BGUFunctionLibrary_GetNearestBoneName Parms{};

	Parms.TargetSkeletalMesh = TargetSkeletalMesh;
	Parms.WorldPosition = std::move(WorldPosition);
	Parms.OptionalWhiteList = std::move(OptionalWhiteList);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACharacter*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ACharacter* UBGUFunctionLibrary::GetPlayerCharacter(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetPlayerCharacter");

	Params::BGUFunctionLibrary_GetPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.GetStreamingVolumeBounds
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ULevelStreaming*                  LevelStreaming                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBox                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FBox UBGUFunctionLibrary::GetStreamingVolumeBounds(class ULevelStreaming* LevelStreaming)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "GetStreamingVolumeBounds");

	Params::BGUFunctionLibrary_GetStreamingVolumeBounds Parms{};

	Parms.LevelStreaming = LevelStreaming;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.MoveLevel
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InWorldOffset                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bActorOnly                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::MoveLevel(class UObject* WorldContextObject, const class FName& LevelName, const struct FVector& InWorldOffset, bool bActorOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "MoveLevel");

	Params::BGUFunctionLibrary_MoveLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;
	Parms.InWorldOffset = std::move(InWorldOffset);
	Parms.bActorOnly = bActorOnly;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.RemoveActorComponentFromLevelActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetLevelActor                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorComponent*                  InActorComponent                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::RemoveActorComponentFromLevelActor(class AActor* TargetLevelActor, class UActorComponent* InActorComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "RemoveActorComponentFromLevelActor");

	Params::BGUFunctionLibrary_RemoveActorComponentFromLevelActor Parms{};

	Parms.TargetLevelActor = TargetLevelActor;
	Parms.InActorComponent = InActorComponent;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.RemoveLevelStreaming
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      LevelName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::RemoveLevelStreaming(class UObject* WorldContextObject, const class FName& LevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "RemoveLevelStreaming");

	Params::BGUFunctionLibrary_RemoveLevelStreaming Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = LevelName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.SerializeActorComponentToLevelActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetLevelActor                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorComponent*                  InActorComponent                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::SerializeActorComponentToLevelActor(class AActor* TargetLevelActor, class UActorComponent* InActorComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "SerializeActorComponentToLevelActor");

	Params::BGUFunctionLibrary_SerializeActorComponentToLevelActor Parms{};

	Parms.TargetLevelActor = TargetLevelActor;
	Parms.InActorComponent = InActorComponent;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.SetAllBodiesBelowSimulatePhysics
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           TargetMesh                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InBoneName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNewSimulate                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludeSelf                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSkipCustomPhysicsType                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::SetAllBodiesBelowSimulatePhysics(class USkeletalMeshComponent* TargetMesh, const class FName& InBoneName, bool bNewSimulate, bool bIncludeSelf, bool bSkipCustomPhysicsType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "SetAllBodiesBelowSimulatePhysics");

	Params::BGUFunctionLibrary_SetAllBodiesBelowSimulatePhysics Parms{};

	Parms.TargetMesh = TargetMesh;
	Parms.InBoneName = InBoneName;
	Parms.bNewSimulate = bNewSimulate;
	Parms.bIncludeSelf = bIncludeSelf;
	Parms.bSkipCustomPhysicsType = bSkipCustomPhysicsType;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.SetBodyBonePhysic
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           TargetMesh                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    NewBool                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::SetBodyBonePhysic(class USkeletalMeshComponent* TargetMesh, class FName BoneName, bool NewBool)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "SetBodyBonePhysic");

	Params::BGUFunctionLibrary_SetBodyBonePhysic Parms{};

	Parms.TargetMesh = TargetMesh;
	Parms.BoneName = BoneName;
	Parms.NewBool = NewBool;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.SetIKValid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    NewValid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::SetIKValid(class ACharacter* Character, bool NewValid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "SetIKValid");

	Params::BGUFunctionLibrary_SetIKValid Parms{};

	Parms.Character = Character;
	Parms.NewValid = NewValid;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.SetLocalKinematics
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           TargetMesh                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    NewBool                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::SetLocalKinematics(class USkeletalMeshComponent* TargetMesh, bool NewBool)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "SetLocalKinematics");

	Params::BGUFunctionLibrary_SetLocalKinematics Parms{};

	Parms.TargetMesh = TargetMesh;
	Parms.NewBool = NewBool;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.SphereComponentInitRadius
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USphereComponent*                 SphereComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibrary::SphereComponentInitRadius(class USphereComponent* SphereComp, float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "SphereComponentInitRadius");

	Params::BGUFunctionLibrary_SphereComponentInitRadius Parms{};

	Parms.SphereComp = SphereComp;
	Parms.Radius = Radius;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibrary.VolumeEncompassPoint
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AVolume*                          Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Point                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SphereRadius                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutDistanceToPoint                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibrary::VolumeEncompassPoint(class AVolume* Volume, const struct FVector& Point, float SphereRadius, float* OutDistanceToPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "VolumeEncompassPoint");

	Params::BGUFunctionLibrary_VolumeEncompassPoint Parms{};

	Parms.Volume = Volume;
	Parms.Point = std::move(Point);
	Parms.SphereRadius = SphereRadius;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.WrapHitResult
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const struct FHitResult&                HitResult                                              (Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FUStGSHitResult                  ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FUStGSHitResult UBGUFunctionLibrary::WrapHitResult(const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibrary", "WrapHitResult");

	Params::BGUFunctionLibrary_WrapHitResult Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibrary.MakeUniqueTamerMonsterName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ULevel*                           SpawnLevel                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             InBaseName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UBGUFunctionLibrary::MakeUniqueTamerMonsterName(class ULevel* SpawnLevel, class FName InBaseName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibrary", "MakeUniqueTamerMonsterName");

	Params::BGUFunctionLibrary_MakeUniqueTamerMonsterName Parms{};

	Parms.SpawnLevel = SpawnLevel;
	Parms.InBaseName = InBaseName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.AddNotifyPreloadedAsset
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Notify                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Asset                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::AddNotifyPreloadedAsset(class UObject* Notify, class UObject* Asset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "AddNotifyPreloadedAsset");

	Params::BGUFunctionLibraryForCS_AddNotifyPreloadedAsset Parms{};

	Parms.Notify = Notify;
	Parms.Asset = Asset;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUBindOnActorBeginOverlapEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUBindOnActorBeginOverlapEvent(class AActor* Actor, class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUBindOnActorBeginOverlapEvent");

	Params::BGUFunctionLibraryForCS_BGUBindOnActorBeginOverlapEvent Parms{};

	Parms.Actor = Actor;
	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUBindOnActorEndOverlapEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUBindOnActorEndOverlapEvent(class AActor* Actor, class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUBindOnActorEndOverlapEvent");

	Params::BGUFunctionLibraryForCS_BGUBindOnActorEndOverlapEvent Parms{};

	Parms.Actor = Actor;
	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUBindOnAllSetLevelsStateFinished
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUBindOnAllSetLevelsStateFinished(class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUBindOnAllSetLevelsStateFinished");

	Params::BGUFunctionLibraryForCS_BGUBindOnAllSetLevelsStateFinished Parms{};

	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUBindOnComponentBeginOverlapEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUBindOnComponentBeginOverlapEvent(class UPrimitiveComponent* Comp, class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUBindOnComponentBeginOverlapEvent");

	Params::BGUFunctionLibraryForCS_BGUBindOnComponentBeginOverlapEvent Parms{};

	Parms.Comp = Comp;
	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUBindOnComponentEndOverlapEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUBindOnComponentEndOverlapEvent(class UPrimitiveComponent* Comp, class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUBindOnComponentEndOverlapEvent");

	Params::BGUFunctionLibraryForCS_BGUBindOnComponentEndOverlapEvent Parms{};

	Parms.Comp = Comp;
	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUBindOnComponentHitEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Func_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUBindOnComponentHitEvent(class UPrimitiveComponent* Comp, class UObject* Obj, class FName Func_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUBindOnComponentHitEvent");

	Params::BGUFunctionLibraryForCS_BGUBindOnComponentHitEvent Parms{};

	Parms.Comp = Comp;
	Parms.Obj = Obj;
	Parms.Func_0 = Func_0;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUBindOnSetLevelsStateFinished
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUBindOnSetLevelsStateFinished(class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUBindOnSetLevelsStateFinished");

	Params::BGUFunctionLibraryForCS_BGUBindOnSetLevelsStateFinished Parms{};

	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUComputeActorHitMovePenetration
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           SelfActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UHitMoveOverlapOtherActorCollisionsInfo*>&OverlappedOtherActorInfos                              (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// float                                   SelfWeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   PlaneNormalVector                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MaxComputeRound                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Epsilon                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UBGUFunctionLibraryForCS::BGUComputeActorHitMovePenetration(class AActor* SelfActor, const TArray<class UHitMoveOverlapOtherActorCollisionsInfo*>& OverlappedOtherActorInfos, float SelfWeight, const struct FVector& PlaneNormalVector, int32 MaxComputeRound, float Epsilon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUComputeActorHitMovePenetration");

	Params::BGUFunctionLibraryForCS_BGUComputeActorHitMovePenetration Parms{};

	Parms.SelfActor = SelfActor;
	Parms.OverlappedOtherActorInfos = std::move(OverlappedOtherActorInfos);
	Parms.SelfWeight = SelfWeight;
	Parms.PlaneNormalVector = std::move(PlaneNormalVector);
	Parms.MaxComputeRound = MaxComputeRound;
	Parms.Epsilon = Epsilon;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUCreateLandscapeHeightMap
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ALandscape*                       Landscape                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PackageName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AssetName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UBGUFunctionLibraryForCS::BGUCreateLandscapeHeightMap(class ALandscape* Landscape, const class FString& PackageName, const class FString& AssetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUCreateLandscapeHeightMap");

	Params::BGUFunctionLibraryForCS_BGUCreateLandscapeHeightMap Parms{};

	Parms.Landscape = Landscape;
	Parms.PackageName = std::move(PackageName);
	Parms.AssetName = std::move(AssetName);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawDebugAnnularSector
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InnerRadius                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OuterRadius                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HalfAngle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawDebugAnnularSector(const class UWorld* World, const struct FVector& CenterPos, const struct FVector& Direction, float InnerRadius, float OuterRadius, float HalfAngle, const struct FColor& Color, float Duration, float Thickness, int32 Segments)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawDebugAnnularSector");

	Params::BGUFunctionLibraryForCS_BGUDrawDebugAnnularSector Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Direction = std::move(Direction);
	Parms.InnerRadius = InnerRadius;
	Parms.OuterRadius = OuterRadius;
	Parms.HalfAngle = HalfAngle;
	Parms.Color = std::move(Color);
	Parms.Duration = Duration;
	Parms.Thickness = Thickness;
	Parms.Segments = Segments;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawDebugCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Raidus                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawDebugCircle(const class UWorld* World, const struct FVector& CenterPos, float Raidus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawDebugCircle");

	Params::BGUFunctionLibraryForCS_BGUDrawDebugCircle Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Raidus = Raidus;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawDebugCircleEx
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Raidus                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KeepTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawDebugCircleEx(const class UWorld* World, const struct FVector& CenterPos, float Raidus, float KeepTime, const struct FColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawDebugCircleEx");

	Params::BGUFunctionLibraryForCS_BGUDrawDebugCircleEx Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Raidus = Raidus;
	Parms.KeepTime = KeepTime;
	Parms.Color = std::move(Color);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawDebugRect
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Width                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Length                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawDebugRect(const class UWorld* World, const struct FVector& CenterPos, const struct FVector& Direction, float Width, float Length)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawDebugRect");

	Params::BGUFunctionLibraryForCS_BGUDrawDebugRect Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Direction = std::move(Direction);
	Parms.Width = Width;
	Parms.Length = Length;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawDebugSphere
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Raidus                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawDebugSphere(const class UWorld* World, const struct FVector& CenterPos, float Raidus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawDebugSphere");

	Params::BGUFunctionLibraryForCS_BGUDrawDebugSphere Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Raidus = Raidus;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawDebugSphereEx
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Raidus                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KeepTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawDebugSphereEx(const class UWorld* World, const struct FVector& CenterPos, float Raidus, float KeepTime, const struct FColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawDebugSphereEx");

	Params::BGUFunctionLibraryForCS_BGUDrawDebugSphereEx Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Raidus = Raidus;
	Parms.KeepTime = KeepTime;
	Parms.Color = std::move(Color);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawLineArrow
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ArrowSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawLineArrow(const class UWorld* World, const struct FVector& LineStart, const struct FVector& LineEnd, float ArrowSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawLineArrow");

	Params::BGUFunctionLibraryForCS_BGUDrawLineArrow Parms{};

	Parms.World = World;
	Parms.LineStart = std::move(LineStart);
	Parms.LineEnd = std::move(LineEnd);
	Parms.ArrowSize = ArrowSize;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawLineArrowEx
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ArrowSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsPersistentLines                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawLineArrowEx(const class UWorld* World, const struct FVector& LineStart, const struct FVector& LineEnd, float ArrowSize, const struct FColor& Color, bool IsPersistentLines, float LifeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawLineArrowEx");

	Params::BGUFunctionLibraryForCS_BGUDrawLineArrowEx Parms{};

	Parms.World = World;
	Parms.LineStart = std::move(LineStart);
	Parms.LineEnd = std::move(LineEnd);
	Parms.ArrowSize = ArrowSize;
	Parms.Color = std::move(Color);
	Parms.IsPersistentLines = IsPersistentLines;
	Parms.LifeTime = LifeTime;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawSphereSweep
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Start                                                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FTransform&                End                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawSphereSweep(const class UWorld* World, const struct FTransform& Start, const struct FTransform& End, float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawSphereSweep");

	Params::BGUFunctionLibraryForCS_BGUDrawSphereSweep Parms{};

	Parms.World = World;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.Radius = Radius;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BguDrawSphereSweepWithColor
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Start                                                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FTransform&                End                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BguDrawSphereSweepWithColor(const class UWorld* World, const struct FTransform& Start, const struct FTransform& End, float Radius, const struct FColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BguDrawSphereSweepWithColor");

	Params::BGUFunctionLibraryForCS_BguDrawSphereSweepWithColor Parms{};

	Parms.World = World;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.Radius = Radius;
	Parms.Color = std::move(Color);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUDrawSweepCheckShape
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FGSSweepCheckShapeInfo&    SweepCheckShapeInfo                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUDrawSweepCheckShape(const class UWorld* World, const struct FVector& CenterPos, const struct FQuat& Rot, const struct FGSSweepCheckShapeInfo& SweepCheckShapeInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUDrawSweepCheckShape");

	Params::BGUFunctionLibraryForCS_BGUDrawSweepCheckShape Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Rot = std::move(Rot);
	Parms.SweepCheckShapeInfo = std::move(SweepCheckShapeInfo);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BguDrawSweepCheckShapeWithColor
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     World                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CenterPos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FGSSweepCheckShapeInfo&    SweepCheckShapeInfo                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BguDrawSweepCheckShapeWithColor(const class UWorld* World, const struct FVector& CenterPos, const struct FQuat& Rot, const struct FGSSweepCheckShapeInfo& SweepCheckShapeInfo, const struct FColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BguDrawSweepCheckShapeWithColor");

	Params::BGUFunctionLibraryForCS_BguDrawSweepCheckShapeWithColor Parms{};

	Parms.World = World;
	Parms.CenterPos = std::move(CenterPos);
	Parms.Rot = std::move(Rot);
	Parms.SweepCheckShapeInfo = std::move(SweepCheckShapeInfo);
	Parms.Color = std::move(Color);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUEnableActorTick
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUEnableActorTick(class AActor* Actor, bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUEnableActorTick");

	Params::BGUFunctionLibraryForCS_BGUEnableActorTick Parms{};

	Parms.Actor = Actor;
	Parms.bEnable = bEnable;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUExceutePyCode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    PyPath                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUExceutePyCode(const class FString& PyPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUExceutePyCode");

	Params::BGUFunctionLibraryForCS_BGUExceutePyCode Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetActorLevelName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Unit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGUFunctionLibraryForCS::BGUGetActorLevelName(class AActor* Unit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetActorLevelName");

	Params::BGUFunctionLibraryForCS_BGUGetActorLevelName Parms{};

	Parms.Unit = Unit;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetAIStimulusWasSuccessfullySensed
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FAIStimulus&               Stimulus                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetAIStimulusWasSuccessfullySensed(const struct FAIStimulus& Stimulus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetAIStimulusWasSuccessfullySensed");

	Params::BGUFunctionLibraryForCS_BGUGetAIStimulusWasSuccessfullySensed Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetAllActorsFromGroupActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           GroupActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRecurse                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UBGUFunctionLibraryForCS::BGUGetAllActorsFromGroupActor(class AActor* GroupActor, bool bRecurse)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetAllActorsFromGroupActor");

	Params::BGUFunctionLibraryForCS_BGUGetAllActorsFromGroupActor Parms{};

	Parms.GroupActor = GroupActor;
	Parms.bRecurse = bRecurse;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetBodyRadius
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           SkMeshComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bGetWelded                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibraryForCS::BGUGetBodyRadius(class USkeletalMeshComponent* SkMeshComp, class FName BoneName, bool bGetWelded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetBodyRadius");

	Params::BGUFunctionLibraryForCS_BGUGetBodyRadius Parms{};

	Parms.SkMeshComp = SkMeshComp;
	Parms.BoneName = BoneName;
	Parms.bGetWelded = bGetWelded;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetBounds
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              PrimComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         Origin                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         BoxExtent                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUGetBounds(class UPrimitiveComponent* PrimComp, struct FVector* Origin, struct FVector* BoxExtent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetBounds");

	Params::BGUFunctionLibraryForCS_BGUGetBounds Parms{};

	Parms.PrimComp = PrimComp;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function b1.BGUFunctionLibraryForCS.BGUGetCurActiveMontageInstID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAnimInstance*                    AnimInstance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFunctionLibraryForCS::BGUGetCurActiveMontageInstID(class UAnimInstance* AnimInstance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetCurActiveMontageInstID");

	Params::BGUFunctionLibraryForCS_BGUGetCurActiveMontageInstID Parms{};

	Parms.AnimInstance = AnimInstance;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetCurrentTime
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibraryForCS::BGUGetCurrentTime(class UObject* WorldContextObject, bool* IsValid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetCurrentTime");

	Params::BGUFunctionLibraryForCS_BGUGetCurrentTime Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetFloatValueTableRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UDataTable*                       DataTable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             RowName                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGSFloatValueTableRow*           Result                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// const class FString&                    ContextString                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWarnIfRowMissing                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetFloatValueTableRow(class UDataTable* DataTable, class FName RowName, struct FGSFloatValueTableRow* Result, const class FString& ContextString, bool bWarnIfRowMissing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetFloatValueTableRow");

	Params::BGUFunctionLibraryForCS_BGUGetFloatValueTableRow Parms{};

	Parms.DataTable = DataTable;
	Parms.RowName = RowName;
	Parms.ContextString = std::move(ContextString);
	Parms.bWarnIfRowMissing = bWarnIfRowMissing;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetIsBuildShipping
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetIsBuildShipping()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetIsBuildShipping");

	Params::BGUFunctionLibraryForCS_BGUGetIsBuildShipping Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetIsEditor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetIsEditor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetIsEditor");

	Params::BGUFunctionLibraryForCS_BGUGetIsEditor Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetIsInEditorPreview
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetIsInEditorPreview(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetIsInEditorPreview");

	Params::BGUFunctionLibraryForCS_BGUGetIsInEditorPreview Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetIsInGameWorld
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetIsInGameWorld(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetIsInGameWorld");

	Params::BGUFunctionLibraryForCS_BGUGetIsInGameWorld Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetIsRuntionShowCollision
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetIsRuntionShowCollision(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetIsRuntionShowCollision");

	Params::BGUFunctionLibraryForCS_BGUGetIsRuntionShowCollision Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetLandscapeExtent
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ALandscape*                       Landscape                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  MinX                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  MinY                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  MaxX                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  MaxY                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUGetLandscapeExtent(class ALandscape* Landscape, int32* MinX, int32* MinY, int32* MaxX, int32* MaxY)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetLandscapeExtent");

	Params::BGUFunctionLibraryForCS_BGUGetLandscapeExtent Parms{};

	Parms.Landscape = Landscape;

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

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

	Func->FunctionFlags = Flgs;

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

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

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

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


// Function b1.BGUFunctionLibraryForCS.BGUGetLevelSequenceCurTime
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ULevelSequencePlayer*             LeveleSequencePlayer                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibraryForCS::BGUGetLevelSequenceCurTime(class ULevelSequencePlayer* LeveleSequencePlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetLevelSequenceCurTime");

	Params::BGUFunctionLibraryForCS_BGUGetLevelSequenceCurTime Parms{};

	Parms.LeveleSequencePlayer = LeveleSequencePlayer;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetLevelSequenceLength
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ULevelSequencePlayer*             LeveleSequencePlayer                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibraryForCS::BGUGetLevelSequenceLength(class ULevelSequencePlayer* LeveleSequencePlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetLevelSequenceLength");

	Params::BGUFunctionLibraryForCS_BGUGetLevelSequenceLength Parms{};

	Parms.LeveleSequencePlayer = LeveleSequencePlayer;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetMeshPredictedLODLevel
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class USkeletalMeshComponent*           MeshComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFunctionLibraryForCS::BGUGetMeshPredictedLODLevel(class USkeletalMeshComponent* MeshComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetMeshPredictedLODLevel");

	Params::BGUFunctionLibraryForCS_BGUGetMeshPredictedLODLevel Parms{};

	Parms.MeshComp = MeshComp;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetPaperSpriteSize
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UPaperSprite*                     PaperSprite                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector2D                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector2D UBGUFunctionLibraryForCS::BGUGetPaperSpriteSize(class UPaperSprite* PaperSprite)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetPaperSpriteSize");

	Params::BGUFunctionLibraryForCS_BGUGetPaperSpriteSize Parms{};

	Parms.PaperSprite = PaperSprite;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetPARadiusByBoneName
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UPhysicsAsset*                    PA                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  BodyRadius                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFunctionLibraryForCS::BGUGetPARadiusByBoneName(class UPhysicsAsset* PA, class FName BoneName, float* BodyRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetPARadiusByBoneName");

	Params::BGUFunctionLibraryForCS_BGUGetPARadiusByBoneName Parms{};

	Parms.PA = PA;
	Parms.BoneName = BoneName;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetParticleSystemIsLooping
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UParticleSystem*            ParticleForPlay                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUGetParticleSystemIsLooping(const class UParticleSystem* ParticleForPlay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetParticleSystemIsLooping");

	Params::BGUFunctionLibraryForCS_BGUGetParticleSystemIsLooping Parms{};

	Parms.ParticleForPlay = ParticleForPlay;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUGetSectionFromProceduralMesh
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UProceduralMeshComponent*         InProcMesh                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SectionIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FVector>*                 Vertices                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<int32>*                          Triangles                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<struct FVector>*                 Normals                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<struct FVector2D>*               UVs                                                    (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<struct FProcMeshTangent>*        Tangents                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUGetSectionFromProceduralMesh(class UProceduralMeshComponent* InProcMesh, int32 SectionIndex, TArray<struct FVector>* Vertices, TArray<int32>* Triangles, TArray<struct FVector>* Normals, TArray<struct FVector2D>* UVs, TArray<struct FProcMeshTangent>* Tangents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetSectionFromProceduralMesh");

	Params::BGUFunctionLibraryForCS_BGUGetSectionFromProceduralMesh Parms{};

	Parms.InProcMesh = InProcMesh;
	Parms.SectionIndex = SectionIndex;

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

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

	Func->FunctionFlags = Flgs;

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

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

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

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

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


// Function b1.BGUFunctionLibraryForCS.BGUGetUWorld
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          InnerObject                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWorld*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWorld* UBGUFunctionLibraryForCS::BGUGetUWorld(class UObject* InnerObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUGetUWorld");

	Params::BGUFunctionLibraryForCS_BGUGetUWorld Parms{};

	Parms.InnerObject = InnerObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUIsBlackBoardKeyTypeMatch
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBlackboardKeyType*               BBKey                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBBKeyType                              BBKeyType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUIsBlackBoardKeyTypeMatch(class UBlackboardKeyType* BBKey, EBBKeyType BBKeyType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUIsBlackBoardKeyTypeMatch");

	Params::BGUFunctionLibraryForCS_BGUIsBlackBoardKeyTypeMatch Parms{};

	Parms.BBKey = BBKey;
	Parms.BBKeyType = BBKeyType;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUMovementComponentHandleImpact
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UMovementComponent*               MoveComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   TimeSlice                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   MoveDelta                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUMovementComponentHandleImpact(class UMovementComponent* MoveComp, const struct FHitResult& Hit, float TimeSlice, const struct FVector& MoveDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUMovementComponentHandleImpact");

	Params::BGUFunctionLibraryForCS_BGUMovementComponentHandleImpact Parms{};

	Parms.MoveComp = MoveComp;
	Parms.Hit = std::move(Hit);
	Parms.TimeSlice = TimeSlice;
	Parms.MoveDelta = std::move(MoveDelta);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUMovementComponentSlideAlongSurface
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UMovementComponent*               MoveComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Normal                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                InHit                                                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bHandleImpact                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGUFunctionLibraryForCS::BGUMovementComponentSlideAlongSurface(class UMovementComponent* MoveComp, const struct FVector& Delta, float Time, const struct FVector& Normal, const struct FHitResult& InHit, bool bHandleImpact, struct FHitResult* OutHit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUMovementComponentSlideAlongSurface");

	Params::BGUFunctionLibraryForCS_BGUMovementComponentSlideAlongSurface Parms{};

	Parms.MoveComp = MoveComp;
	Parms.Delta = std::move(Delta);
	Parms.Time = Time;
	Parms.Normal = std::move(Normal);
	Parms.InHit = std::move(InHit);
	Parms.bHandleImpact = bHandleImpact;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGURegistComp
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorComponent*                  ActorComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGURegistComp(class UObject* WorldContextObject, class UActorComponent* ActorComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGURegistComp");

	Params::BGUFunctionLibraryForCS_BGURegistComp Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActorComp = ActorComp;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGURestartBT
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ABGUAIController*                 AIController                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGURestartBT(class ABGUAIController* AIController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGURestartBT");

	Params::BGUFunctionLibraryForCS_BGURestartBT Parms{};

	Parms.AIController = AIController;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUSetDecalSize
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UDecalComponent*                  DecalComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUSetDecalSize(class UDecalComponent* DecalComp, const struct FVector& Size)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUSetDecalSize");

	Params::BGUFunctionLibraryForCS_BGUSetDecalSize Parms{};

	Parms.DecalComp = DecalComp;
	Parms.Size = std::move(Size);

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUSetIKComponentValid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    NewValid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUSetIKComponentValid(class ACharacter* Character, bool NewValid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUSetIKComponentValid");

	Params::BGUFunctionLibraryForCS_BGUSetIKComponentValid Parms{};

	Parms.Character = Character;
	Parms.NewValid = NewValid;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUSetParticleSysCompPoolingMethod
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UParticleSystemComponent*         ParticleComp                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPSCPoolMethod                          PoolMethod                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUSetParticleSysCompPoolingMethod(class UParticleSystemComponent* ParticleComp, EPSCPoolMethod PoolMethod)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUSetParticleSysCompPoolingMethod");

	Params::BGUFunctionLibraryForCS_BGUSetParticleSysCompPoolingMethod Parms{};

	Parms.ParticleComp = ParticleComp;
	Parms.PoolMethod = PoolMethod;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUSetParticleSysSortPriority
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UParticleSystemComponent*         ParticleSystemComp                                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SortPriority                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUSetParticleSysSortPriority(class UParticleSystemComponent* ParticleSystemComp, int32 SortPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUSetParticleSysSortPriority");

	Params::BGUFunctionLibraryForCS_BGUSetParticleSysSortPriority Parms{};

	Parms.ParticleSystemComp = ParticleSystemComp;
	Parms.SortPriority = SortPriority;

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

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

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUSliceProceduralMesh
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UProceduralMeshComponent*         InProcMesh                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   PlanePosition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   PlaneNormal                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCreateOtherHalf                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UProceduralMeshComponent**        OutOtherHalfProcMesh                                   (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EProcMeshSliceCapOption                 CapOption                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInterface*               CapMaterial                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUSliceProceduralMesh(class UProceduralMeshComponent* InProcMesh, const struct FVector& PlanePosition, const struct FVector& PlaneNormal, bool bCreateOtherHalf, class UProceduralMeshComponent** OutOtherHalfProcMesh, EProcMeshSliceCapOption CapOption, class UMaterialInterface* CapMaterial)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUSliceProceduralMesh");

	Params::BGUFunctionLibraryForCS_BGUSliceProceduralMesh Parms{};

	Parms.InProcMesh = InProcMesh;
	Parms.PlanePosition = std::move(PlanePosition);
	Parms.PlaneNormal = std::move(PlaneNormal);
	Parms.bCreateOtherHalf = bCreateOtherHalf;
	Parms.CapOption = CapOption;
	Parms.CapMaterial = CapMaterial;

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

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutOtherHalfProcMesh != nullptr)
		*OutOtherHalfProcMesh = Parms.OutOtherHalfProcMesh;
}


// Function b1.BGUFunctionLibraryForCS.BGUSpawnDecalAttached
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UMaterialInterface*               DecalMaterial                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   DecalSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  AttachToComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AttachPointName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EAttachLocation                         LocationType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeSpan                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDecalComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UDecalComponent* UBGUFunctionLibraryForCS::BGUSpawnDecalAttached(class UMaterialInterface* DecalMaterial, const struct FVector& DecalSize, class USceneComponent* AttachToComponent, class FName AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, EAttachLocation LocationType, float LifeSpan)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUSpawnDecalAttached");

	Params::BGUFunctionLibraryForCS_BGUSpawnDecalAttached Parms{};

	Parms.DecalMaterial = DecalMaterial;
	Parms.DecalSize = std::move(DecalSize);
	Parms.AttachToComponent = AttachToComponent;
	Parms.AttachPointName = AttachPointName;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.LocationType = LocationType;
	Parms.LifeSpan = LifeSpan;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUTeleportTo
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           Owner                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   DestLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  DestRotation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bIsATest                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNoCheck                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::BGUTeleportTo(class AActor* Owner, const struct FVector& DestLocation, const struct FRotator& DestRotation, bool bIsATest, bool bNoCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUTeleportTo");

	Params::BGUFunctionLibraryForCS_BGUTeleportTo Parms{};

	Parms.Owner = Owner;
	Parms.DestLocation = std::move(DestLocation);
	Parms.DestRotation = std::move(DestRotation);
	Parms.bIsATest = bIsATest;
	Parms.bNoCheck = bNoCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.BGUUnBindOnAllSetLevelsStateFinished
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUUnBindOnAllSetLevelsStateFinished(class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUUnBindOnAllSetLevelsStateFinished");

	Params::BGUFunctionLibraryForCS_BGUUnBindOnAllSetLevelsStateFinished Parms{};

	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUUnBindOnComponentBeginOverlapEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUUnBindOnComponentBeginOverlapEvent(class UPrimitiveComponent* Comp, class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUUnBindOnComponentBeginOverlapEvent");

	Params::BGUFunctionLibraryForCS_BGUUnBindOnComponentBeginOverlapEvent Parms{};

	Parms.Comp = Comp;
	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUUnBindOnComponentEndOverlapEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUUnBindOnComponentEndOverlapEvent(class UPrimitiveComponent* Comp, class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUUnBindOnComponentEndOverlapEvent");

	Params::BGUFunctionLibraryForCS_BGUUnBindOnComponentEndOverlapEvent Parms{};

	Parms.Comp = Comp;
	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUUnBindOnComponentHitEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Func_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUUnBindOnComponentHitEvent(class UPrimitiveComponent* Comp, class UObject* Obj, class FName Func_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUUnBindOnComponentHitEvent");

	Params::BGUFunctionLibraryForCS_BGUUnBindOnComponentHitEvent Parms{};

	Parms.Comp = Comp;
	Parms.Obj = Obj;
	Parms.Func_0 = Func_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.BGUUnBindOnSetLevelsStateFinished
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Obj                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FuncName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::BGUUnBindOnSetLevelsStateFinished(class UObject* Obj, class FName FuncName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "BGUUnBindOnSetLevelsStateFinished");

	Params::BGUFunctionLibraryForCS_BGUUnBindOnSetLevelsStateFinished Parms{};

	Parms.Obj = Obj;
	Parms.FuncName = FuncName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.CallSectionManuallyChangeOnCrossSectionNotifies
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ABGUCharacter*                    OwnerChar                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NewSectionName                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::CallSectionManuallyChangeOnCrossSectionNotifies(class ABGUCharacter* OwnerChar, const class FName& NewSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "CallSectionManuallyChangeOnCrossSectionNotifies");

	Params::BGUFunctionLibraryForCS_CallSectionManuallyChangeOnCrossSectionNotifies Parms{};

	Parms.OwnerChar = OwnerChar;
	Parms.NewSectionName = NewSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.CompForceUpdateOverlaps
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDoNotifies                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibraryForCS::CompForceUpdateOverlaps(class UPrimitiveComponent* Comp, bool bDoNotifies)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "CompForceUpdateOverlaps");

	Params::BGUFunctionLibraryForCS_CompForceUpdateOverlaps Parms{};

	Parms.Comp = Comp;
	Parms.bDoNotifies = bDoNotifies;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.ConvertObjectTypeToCollisionChannel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EObjectTypeQuery                        ObjectType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECollisionChannel UBGUFunctionLibraryForCS::ConvertObjectTypeToCollisionChannel(EObjectTypeQuery ObjectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "ConvertObjectTypeToCollisionChannel");

	Params::BGUFunctionLibraryForCS_ConvertObjectTypeToCollisionChannel Parms{};

	Parms.ObjectType = ObjectType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.ConvertToObjectType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EObjectTypeQuery                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EObjectTypeQuery UBGUFunctionLibraryForCS::ConvertToObjectType(ECollisionChannel CollisionChannel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "ConvertToObjectType");

	Params::BGUFunctionLibraryForCS_ConvertToObjectType Parms{};

	Parms.CollisionChannel = CollisionChannel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.ConvertToTraceType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETraceTypeQuery                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ETraceTypeQuery UBGUFunctionLibraryForCS::ConvertToTraceType(ECollisionChannel CollisionChannel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "ConvertToTraceType");

	Params::BGUFunctionLibraryForCS_ConvertToTraceType Parms{};

	Parms.CollisionChannel = CollisionChannel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.ConvertTraceTypeToCollisionChannel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// ETraceTypeQuery                         TraceType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECollisionChannel UBGUFunctionLibraryForCS::ConvertTraceTypeToCollisionChannel(ETraceTypeQuery TraceType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "ConvertTraceTypeToCollisionChannel");

	Params::BGUFunctionLibraryForCS_ConvertTraceTypeToCollisionChannel Parms{};

	Parms.TraceType = TraceType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.CopyProceduralMeshFromStaticMeshComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*             StaticMeshComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LODIndex                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UProceduralMeshComponent*         ProcMeshComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCreateCollision                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::CopyProceduralMeshFromStaticMeshComponent(class UStaticMeshComponent* StaticMeshComponent, int32 LODIndex, class UProceduralMeshComponent* ProcMeshComponent, bool bCreateCollision)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "CopyProceduralMeshFromStaticMeshComponent");

	Params::BGUFunctionLibraryForCS_CopyProceduralMeshFromStaticMeshComponent Parms{};

	Parms.StaticMeshComponent = StaticMeshComponent;
	Parms.LODIndex = LODIndex;
	Parms.ProcMeshComponent = ProcMeshComponent;
	Parms.bCreateCollision = bCreateCollision;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.RemoveAllQueriesByQuerier
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::RemoveAllQueriesByQuerier(class UObject* Querier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "RemoveAllQueriesByQuerier");

	Params::BGUFunctionLibraryForCS_RemoveAllQueriesByQuerier Parms{};

	Parms.Querier = Querier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.RequestGameplayTag
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             TagName                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ErrorIfNotFound                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayTag UBGUFunctionLibraryForCS::RequestGameplayTag(class FName TagName, bool ErrorIfNotFound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "RequestGameplayTag");

	Params::BGUFunctionLibraryForCS_RequestGameplayTag Parms{};

	Parms.TagName = TagName;
	Parms.ErrorIfNotFound = ErrorIfNotFound;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibraryForCS.ValidateMontagesForCrossSectionNS
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ResourcePath                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::ValidateMontagesForCrossSectionNS(const class FString& ResourcePath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibraryForCS", "ValidateMontagesForCrossSectionNS");

	Params::BGUFunctionLibraryForCS_ValidateMontagesForCrossSectionNS Parms{};

	Parms.ResourcePath = std::move(ResourcePath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.OnActorBeginOverlapPlaceholder
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlapActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::OnActorBeginOverlapPlaceholder(class AActor* OverlapActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibraryForCS", "OnActorBeginOverlapPlaceholder");

	Params::BGUFunctionLibraryForCS_OnActorBeginOverlapPlaceholder Parms{};

	Parms.OverlapActor = OverlapActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.OnActorEndOverlapPlaceholder
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlapActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::OnActorEndOverlapPlaceholder(class AActor* OverlapActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibraryForCS", "OnActorEndOverlapPlaceholder");

	Params::BGUFunctionLibraryForCS_OnActorEndOverlapPlaceholder Parms{};

	Parms.OverlapActor = OverlapActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.OnAllSetLevelsStateFinishedPlaceHolder
// (Final, Native, Public)

void UBGUFunctionLibraryForCS::OnAllSetLevelsStateFinishedPlaceHolder()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibraryForCS", "OnAllSetLevelsStateFinishedPlaceHolder");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.OnComponentBeginOverlapPlaceholder
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::OnComponentBeginOverlapPlaceholder(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibraryForCS", "OnComponentBeginOverlapPlaceholder");

	Params::BGUFunctionLibraryForCS_OnComponentBeginOverlapPlaceholder Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.OnComponentEndOverlapPlaceholder
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::OnComponentEndOverlapPlaceholder(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibraryForCS", "OnComponentEndOverlapPlaceholder");

	Params::BGUFunctionLibraryForCS_OnComponentEndOverlapPlaceholder Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.OnComponentHitPlaceholder
// (Final, Native, Public, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitImpule                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::OnComponentHitPlaceholder(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& HitImpule, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibraryForCS", "OnComponentHitPlaceholder");

	Params::BGUFunctionLibraryForCS_OnComponentHitPlaceholder Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.HitImpule = std::move(HitImpule);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibraryForCS.OnSetLevelsStateFinishedPlaceHolder
// (Final, Native, Public)
// Parameters:
// const class FString&                    InTargetLevelsKeyword                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InTargetLevelState                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InOperationID                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibraryForCS::OnSetLevelsStateFinishedPlaceHolder(const class FString& InTargetLevelsKeyword, const class FString& InTargetLevelState, int32 InOperationID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUFunctionLibraryForCS", "OnSetLevelsStateFinishedPlaceHolder");

	Params::BGUFunctionLibraryForCS_OnSetLevelsStateFinishedPlaceHolder Parms{};

	Parms.InTargetLevelsKeyword = std::move(InTargetLevelsKeyword);
	Parms.InTargetLevelState = std::move(InTargetLevelState);
	Parms.InOperationID = InOperationID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQCBase.ProvideActorsSetCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class UObject*                          QuerierObject                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           QuerierActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQCBase::ProvideActorsSetCS(class UObject* QuerierObject, class AActor* QuerierActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQCBase", "ProvideActorsSetCS");

	Params::GSEQCBase_ProvideActorsSetCS Parms{};

	Parms.QuerierObject = QuerierObject;
	Parms.QuerierActor = QuerierActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.GSEQCBase.ProvideLocationsSetCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class UObject*                          QuerierObject                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           QuerierActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQCBase::ProvideLocationsSetCS(class UObject* QuerierObject, class AActor* QuerierActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQCBase", "ProvideLocationsSetCS");

	Params::GSEQCBase_ProvideLocationsSetCS Parms{};

	Parms.QuerierObject = QuerierObject;
	Parms.QuerierActor = QuerierActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.GSEQCBase.ProvideSingleActorCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class UObject*                          QuerierObject                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           QuerierActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQCBase::ProvideSingleActorCS(class UObject* QuerierObject, class AActor* QuerierActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQCBase", "ProvideSingleActorCS");

	Params::GSEQCBase_ProvideSingleActorCS Parms{};

	Parms.QuerierObject = QuerierObject;
	Parms.QuerierActor = QuerierActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.GSEQCBase.ProvideSingleLocationCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class UObject*                          QuerierObject                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           QuerierActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQCBase::ProvideSingleLocationCS(class UObject* QuerierObject, class AActor* QuerierActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQCBase", "ProvideSingleLocationCS");

	Params::GSEQCBase_ProvideSingleLocationCS Parms{};

	Parms.QuerierObject = QuerierObject;
	Parms.QuerierActor = QuerierActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUFunctionLibAK.AkCompSetSwitch
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAkComponent*                     AkComp                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkSwitchValue*                   SwitchValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SwitchGroup                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SwitchState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibAK::AkCompSetSwitch(class UAkComponent* AkComp, class UAkSwitchValue* SwitchValue, class FName SwitchGroup, class FName SwitchState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "AkCompSetSwitch");

	Params::BGUFunctionLibAK_AkCompSetSwitch Parms{};

	Parms.AkComp = AkComp;
	Parms.SwitchValue = SwitchValue;
	Parms.SwitchGroup = SwitchGroup;
	Parms.SwitchState = SwitchState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibAK.AkEventPinInGarbageCollector
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PlayingID                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibAK::AkEventPinInGarbageCollector(class UAkAudioEvent* Event, int32 PlayingID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "AkEventPinInGarbageCollector");

	Params::BGUFunctionLibAK_AkEventPinInGarbageCollector Parms{};

	Parms.Event = Event;
	Parms.PlayingID = PlayingID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibAK.BGUAKStopPlayingID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   PlayingID                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FadeOutTimeMs                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FadeOutCurveType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibAK::BGUAKStopPlayingID(int32 PlayingID, int32 FadeOutTimeMs, int32 FadeOutCurveType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "BGUAKStopPlayingID");

	Params::BGUFunctionLibAK_BGUAKStopPlayingID Parms{};

	Parms.PlayingID = PlayingID;
	Parms.FadeOutTimeMs = FadeOutTimeMs;
	Parms.FadeOutCurveType = FadeOutCurveType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibAK.ExecuteActionOnPlayingID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   ActionType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PlayingID                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FadeOutTimeMs                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FadeOutCurveType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibAK::ExecuteActionOnPlayingID(int32 ActionType, int32 PlayingID, int32 FadeOutTimeMs, int32 FadeOutCurveType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "ExecuteActionOnPlayingID");

	Params::BGUFunctionLibAK_ExecuteActionOnPlayingID Parms{};

	Parms.ActionType = ActionType;
	Parms.PlayingID = PlayingID;
	Parms.FadeOutTimeMs = FadeOutTimeMs;
	Parms.FadeOutCurveType = FadeOutCurveType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibAK.GetSourcePlayPosition
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   PlayingID                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFunctionLibAK::GetSourcePlayPosition(int32 PlayingID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "GetSourcePlayPosition");

	Params::BGUFunctionLibAK_GetSourcePlayPosition Parms{};

	Parms.PlayingID = PlayingID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibAK.LoadBank
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    BankName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibAK::LoadBank(const class FString& BankName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "LoadBank");

	Params::BGUFunctionLibAK_LoadBank Parms{};

	Parms.BankName = std::move(BankName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibAK.PostAkEventOnDummyActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    EventName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUFunctionLibAK::PostAkEventOnDummyActor(const class FString& EventName, class UAkAudioEvent* Event)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "PostAkEventOnDummyActor");

	Params::BGUFunctionLibAK_PostAkEventOnDummyActor Parms{};

	Parms.EventName = std::move(EventName);
	Parms.Event = Event;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibAK.SeekOnEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InEventName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     InComponent                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InPercent                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInSeekToNearestMarker                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InPlayingID                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAkResult                               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAkResult UBGUFunctionLibAK::SeekOnEvent(const class FString& InEventName, class UAkComponent* InComponent, float InPercent, bool bInSeekToNearestMarker, int32 InPlayingID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "SeekOnEvent");

	Params::BGUFunctionLibAK_SeekOnEvent Parms{};

	Parms.InEventName = std::move(InEventName);
	Parms.InComponent = InComponent;
	Parms.InPercent = InPercent;
	Parms.bInSeekToNearestMarker = bInSeekToNearestMarker;
	Parms.InPlayingID = InPlayingID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibAK.SetUnrealGlobalSwitch
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             SwitchGroup                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SwitchState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibAK::SetUnrealGlobalSwitch(class FName SwitchGroup, class FName SwitchState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "SetUnrealGlobalSwitch");

	Params::BGUFunctionLibAK_SetUnrealGlobalSwitch Parms{};

	Parms.SwitchGroup = SwitchGroup;
	Parms.SwitchState = SwitchState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibAK.UnLoadBank
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    BankName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUFunctionLibAK::UnLoadBank(const class FString& BankName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibAK", "UnLoadBank");

	Params::BGUFunctionLibAK_UnLoadBank Parms{};

	Parms.BankName = std::move(BankName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibCollisionChannel.BGUGetCollisionResponseToChannels
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        Comp                                                   (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<ECollisionChannel, ECollisionResponse>*OutResponseToChannels                                  (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibCollisionChannel::BGUGetCollisionResponseToChannels(const class UPrimitiveComponent* Comp, TMap<ECollisionChannel, ECollisionResponse>* OutResponseToChannels)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibCollisionChannel", "BGUGetCollisionResponseToChannels");

	Params::BGUFunctionLibCollisionChannel_BGUGetCollisionResponseToChannels Parms{};

	Parms.Comp = Comp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutResponseToChannels != nullptr)
		*OutResponseToChannels = std::move(Parms.OutResponseToChannels);

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibCollisionChannel.BGUSetCollisionResponseToChannels
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Comp                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TMap<ECollisionChannel, ECollisionResponse>&ResponseToChannels                                     (Parm, NativeAccessSpecifierPublic)

void UBGUFunctionLibCollisionChannel::BGUSetCollisionResponseToChannels(class UPrimitiveComponent* Comp, const TMap<ECollisionChannel, ECollisionResponse>& ResponseToChannels)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibCollisionChannel", "BGUSetCollisionResponseToChannels");

	Params::BGUFunctionLibCollisionChannel_BGUSetCollisionResponseToChannels Parms{};

	Parms.Comp = Comp;
	Parms.ResponseToChannels = std::move(ResponseToChannels);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFunctionLibCollisionChannel.ConvertToCollisionChannelByObjectType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EObjectTypeQuery                        ObjectType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECollisionChannel UBGUFunctionLibCollisionChannel::ConvertToCollisionChannelByObjectType(EObjectTypeQuery ObjectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibCollisionChannel", "ConvertToCollisionChannelByObjectType");

	Params::BGUFunctionLibCollisionChannel_ConvertToCollisionChannelByObjectType Parms{};

	Parms.ObjectType = ObjectType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibCollisionChannel.ConvertToCollisionChannelByTraceType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ETraceTypeQuery                         TraceType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECollisionChannel UBGUFunctionLibCollisionChannel::ConvertToCollisionChannelByTraceType(ETraceTypeQuery TraceType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibCollisionChannel", "ConvertToCollisionChannelByTraceType");

	Params::BGUFunctionLibCollisionChannel_ConvertToCollisionChannelByTraceType Parms{};

	Parms.TraceType = TraceType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibCollisionChannel.ConvertToObjectType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EObjectTypeQuery                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EObjectTypeQuery UBGUFunctionLibCollisionChannel::ConvertToObjectType(ECollisionChannel CollisionChannel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibCollisionChannel", "ConvertToObjectType");

	Params::BGUFunctionLibCollisionChannel_ConvertToObjectType Parms{};

	Parms.CollisionChannel = CollisionChannel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibCollisionChannel.ConvertToTraceType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETraceTypeQuery                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ETraceTypeQuery UBGUFunctionLibCollisionChannel::ConvertToTraceType(ECollisionChannel CollisionChannel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibCollisionChannel", "ConvertToTraceType");

	Params::BGUFunctionLibCollisionChannel_ConvertToTraceType Parms{};

	Parms.CollisionChannel = CollisionChannel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUFunctionLibCollisionChannel.GetCollisionProfileData
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UPrimitiveComponent*        Comp                                                   (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      ProfileName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionEnabled*                      OutCollisionEnabled                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel*                      OutObjectType                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<ECollisionChannel, ECollisionResponse>*OutResponseToChannels                                  (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUFunctionLibCollisionChannel::GetCollisionProfileData(const class UPrimitiveComponent* Comp, const class FName& ProfileName, ECollisionEnabled* OutCollisionEnabled, ECollisionChannel* OutObjectType, TMap<ECollisionChannel, ECollisionResponse>* OutResponseToChannels)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFunctionLibCollisionChannel", "GetCollisionProfileData");

	Params::BGUFunctionLibCollisionChannel_GetCollisionProfileData Parms{};

	Parms.Comp = Comp;
	Parms.ProfileName = ProfileName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutCollisionEnabled != nullptr)
		*OutCollisionEnabled = Parms.OutCollisionEnabled;

	if (OutObjectType != nullptr)
		*OutObjectType = Parms.OutObjectType;

	if (OutResponseToChannels != nullptr)
		*OutResponseToChannels = std::move(Parms.OutResponseToChannels);

	return Parms.ReturnValue;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTDecoratorCheckCondition
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTDecoratorCheckCondition(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTDecoratorCheckCondition");

	Params::BGUFuncLibCSDelegateRegister_Register_BTDecoratorCheckCondition Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTServiceActivation
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTServiceActivation(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTServiceActivation");

	Params::BGUFuncLibCSDelegateRegister_Register_BTServiceActivation Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTServiceDeactivation
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTServiceDeactivation(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTServiceDeactivation");

	Params::BGUFuncLibCSDelegateRegister_Register_BTServiceDeactivation Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTServiceSearchStart
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTServiceSearchStart(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTServiceSearchStart");

	Params::BGUFuncLibCSDelegateRegister_Register_BTServiceSearchStart Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTServiceTick
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTServiceTick(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTServiceTick");

	Params::BGUFuncLibCSDelegateRegister_Register_BTServiceTick Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTTaskAbort
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTTaskAbort(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTTaskAbort");

	Params::BGUFuncLibCSDelegateRegister_Register_BTTaskAbort Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTTaskExecute
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTTaskExecute(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTTaskExecute");

	Params::BGUFuncLibCSDelegateRegister_Register_BTTaskExecute Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_BTTaskTick
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_BTTaskTick(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_BTTaskTick");

	Params::BGUFuncLibCSDelegateRegister_Register_BTTaskTick Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_ResetProperty
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_ResetProperty(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_ResetProperty");

	Params::BGUFuncLibCSDelegateRegister_Register_ResetProperty Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_SetCollisionResponseProperty
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_SetCollisionResponseProperty(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_SetCollisionResponseProperty");

	Params::BGUFuncLibCSDelegateRegister_Register_SetCollisionResponseProperty Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_SetEnumProperty
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_SetEnumProperty(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_SetEnumProperty");

	Params::BGUFuncLibCSDelegateRegister_Register_SetEnumProperty Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUFuncLibCSDelegateRegister.Register_SetFloatProperty
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FIntPtr&                   FuncPtr                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUFuncLibCSDelegateRegister::Register_SetFloatProperty(const struct FIntPtr& FuncPtr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUFuncLibCSDelegateRegister", "Register_SetFloatProperty");

	Params::BGUFuncLibCSDelegateRegister_Register_SetFloatProperty Parms{};

	Parms.FuncPtr = std::move(FuncPtr);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.CacheWorldCompositionLevelNames
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::CacheWorldCompositionLevelNames(class UObject* InWorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "CacheWorldCompositionLevelNames");

	Params::BGUWCStreamingFuncLib_CacheWorldCompositionLevelNames Parms{};

	Parms.InWorldContext = InWorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.CacheWorldCompositionStreamingLayers
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::CacheWorldCompositionStreamingLayers(class UObject* InWorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "CacheWorldCompositionStreamingLayers");

	Params::BGUWCStreamingFuncLib_CacheWorldCompositionStreamingLayers Parms{};

	Parms.InWorldContext = InWorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.CheckLevelState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InTargetLevelName                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::CheckLevelState(class UObject* InWorldContext, const class FString& InTargetLevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "CheckLevelState");

	Params::BGUWCStreamingFuncLib_CheckLevelState Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InTargetLevelName = std::move(InTargetLevelName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.DestroyGSWCWorldStreamingSources
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::DestroyGSWCWorldStreamingSources(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "DestroyGSWCWorldStreamingSources");

	Params::BGUWCStreamingFuncLib_DestroyGSWCWorldStreamingSources Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.DisableStreamingSource
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::DisableStreamingSource(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "DisableStreamingSource");

	Params::BGUWCStreamingFuncLib_DisableStreamingSource Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.EnableStreamingSource
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::EnableStreamingSource(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "EnableStreamingSource");

	Params::BGUWCStreamingFuncLib_EnableStreamingSource Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.FlushAllLevelState
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            InExcludedLevelKeywords                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::FlushAllLevelState(class UObject* InWorldContext, const TArray<class FString>& InExcludedLevelKeywords)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "FlushAllLevelState");

	Params::BGUWCStreamingFuncLib_FlushAllLevelState Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InExcludedLevelKeywords = std::move(InExcludedLevelKeywords);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.ForceLoadAllStreamingLevels
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::ForceLoadAllStreamingLevels(class UObject* InWorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "ForceLoadAllStreamingLevels");

	Params::BGUWCStreamingFuncLib_ForceLoadAllStreamingLevels Parms{};

	Parms.InWorldContext = InWorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.GetAllLevelCurrentState
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<class FString, uint8>*             OutLevelStreamingList                                  (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    bIgnoreWCTile                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUWCStreamingFuncLib::GetAllLevelCurrentState(class UObject* InWorldContext, TMap<class FString, uint8>* OutLevelStreamingList, bool bIgnoreWCTile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "GetAllLevelCurrentState");

	Params::BGUWCStreamingFuncLib_GetAllLevelCurrentState Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.bIgnoreWCTile = bIgnoreWCTile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLevelStreamingList != nullptr)
		*OutLevelStreamingList = std::move(Parms.OutLevelStreamingList);

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.GetLevelCurrentStateAndIsConsideredUpdate
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            LevelNames                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TMap<class FString, uint8>*             OutLevelStreamingList                                  (Parm, OutParm, NativeAccessSpecifierPublic)
// TSet<class FString>*                    OutCosideredUpdateSet                                  (Parm, OutParm, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::GetLevelCurrentStateAndIsConsideredUpdate(class UObject* InWorldContext, const TArray<class FString>& LevelNames, TMap<class FString, uint8>* OutLevelStreamingList, TSet<class FString>* OutCosideredUpdateSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "GetLevelCurrentStateAndIsConsideredUpdate");

	Params::BGUWCStreamingFuncLib_GetLevelCurrentStateAndIsConsideredUpdate Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.LevelNames = std::move(LevelNames);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLevelStreamingList != nullptr)
		*OutLevelStreamingList = std::move(Parms.OutLevelStreamingList);

	if (OutCosideredUpdateSet != nullptr)
		*OutCosideredUpdateSet = std::move(Parms.OutCosideredUpdateSet);
}


// Function b1.BGUWCStreamingFuncLib.GetLevelFullNames
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutLevelNames                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUWCStreamingFuncLib::GetLevelFullNames(class UObject* InWorldContext, TArray<class FString>* OutLevelNames)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "GetLevelFullNames");

	Params::BGUWCStreamingFuncLib_GetLevelFullNames Parms{};

	Parms.InWorldContext = InWorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLevelNames != nullptr)
		*OutLevelNames = std::move(Parms.OutLevelNames);

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.GetLevelNames
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutLevelNames                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUWCStreamingFuncLib::GetLevelNames(class UObject* InWorldContext, TArray<class FString>* OutLevelNames)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "GetLevelNames");

	Params::BGUWCStreamingFuncLib_GetLevelNames Parms{};

	Parms.InWorldContext = InWorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLevelNames != nullptr)
		*OutLevelNames = std::move(Parms.OutLevelNames);

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.GetLevelNamesByKeyword
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InLevelNameKeyword                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UBGUWCStreamingFuncLib::GetLevelNamesByKeyword(class UObject* InWorldContext, const class FString& InLevelNameKeyword)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "GetLevelNamesByKeyword");

	Params::BGUWCStreamingFuncLib_GetLevelNamesByKeyword Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InLevelNameKeyword = std::move(InLevelNameKeyword);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.GetProcessingStreamingLevelNum
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUWCStreamingFuncLib::GetProcessingStreamingLevelNum(class UObject* InWorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "GetProcessingStreamingLevelNum");

	Params::BGUWCStreamingFuncLib_GetProcessingStreamingLevelNum Parms{};

	Parms.InWorldContext = InWorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.IsLevelStreamable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InTargetLevelName                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUWCStreamingFuncLib::IsLevelStreamable(class UObject* InWorldContext, const class FString& InTargetLevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "IsLevelStreamable");

	Params::BGUWCStreamingFuncLib_IsLevelStreamable Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InTargetLevelName = std::move(InTargetLevelName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.ModifyStreamingDistanceScaleByStreamingLayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InTargetLayerName                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InTargetLODIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InTargetScaleFactor                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBlockTillStreamingCompleted                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::ModifyStreamingDistanceScaleByStreamingLayer(class UObject* InWorldContext, const class FString& InTargetLayerName, int32 InTargetLODIndex, float InTargetScaleFactor, bool bBlockTillStreamingCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "ModifyStreamingDistanceScaleByStreamingLayer");

	Params::BGUWCStreamingFuncLib_ModifyStreamingDistanceScaleByStreamingLayer Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InTargetLayerName = std::move(InTargetLayerName);
	Parms.InTargetLODIndex = InTargetLODIndex;
	Parms.InTargetScaleFactor = InTargetScaleFactor;
	Parms.bBlockTillStreamingCompleted = bBlockTillStreamingCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.PauseDistanceStreaming
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            InExcludedLevelKeywords                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::PauseDistanceStreaming(class UObject* InWorldContext, const TArray<class FString>& InExcludedLevelKeywords)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "PauseDistanceStreaming");

	Params::BGUWCStreamingFuncLib_PauseDistanceStreaming Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InExcludedLevelKeywords = std::move(InExcludedLevelKeywords);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.QueryProcessingStreamingLevels
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<class FString, class FString>      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

TMap<class FString, class FString> UBGUWCStreamingFuncLib::QueryProcessingStreamingLevels(class UObject* InWorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "QueryProcessingStreamingLevels");

	Params::BGUWCStreamingFuncLib_QueryProcessingStreamingLevels Parms{};

	Parms.InWorldContext = InWorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.RegisterAsStreamingSource
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::RegisterAsStreamingSource(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "RegisterAsStreamingSource");

	Params::BGUWCStreamingFuncLib_RegisterAsStreamingSource Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.SetLevelsState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InTargetLevelNameOrKeyword                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EGSLevelState                           InTargetState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InOperationID                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bKeywordMatch                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBlockOnLoad                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FGSSetLevelStateFailedInfo>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FGSSetLevelStateFailedInfo> UBGUWCStreamingFuncLib::SetLevelsState(class UObject* InWorldContext, const class FString& InTargetLevelNameOrKeyword, EGSLevelState InTargetState, int32 InOperationID, bool bKeywordMatch, bool bBlockOnLoad)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "SetLevelsState");

	Params::BGUWCStreamingFuncLib_SetLevelsState Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InTargetLevelNameOrKeyword = std::move(InTargetLevelNameOrKeyword);
	Parms.InTargetState = InTargetState;
	Parms.InOperationID = InOperationID;
	Parms.bKeywordMatch = bKeywordMatch;
	Parms.bBlockOnLoad = bBlockOnLoad;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.SetLevelsStateByNames
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            InTargetLevelNames                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// EGSLevelState                           InTargetState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InOperationID                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBlockOnLoad                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FGSSetLevelStateFailedInfo>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FGSSetLevelStateFailedInfo> UBGUWCStreamingFuncLib::SetLevelsStateByNames(class UObject* InWorldContext, const TArray<class FString>& InTargetLevelNames, EGSLevelState InTargetState, int32 InOperationID, bool bBlockOnLoad)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "SetLevelsStateByNames");

	Params::BGUWCStreamingFuncLib_SetLevelsStateByNames Parms{};

	Parms.InWorldContext = InWorldContext;
	Parms.InTargetLevelNames = std::move(InTargetLevelNames);
	Parms.InTargetState = InTargetState;
	Parms.InOperationID = InOperationID;
	Parms.bBlockOnLoad = bBlockOnLoad;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUWCStreamingFuncLib.SetStreamingManagerViewSource
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   ViewLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::SetStreamingManagerViewSource(const struct FVector& ViewLocation, float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "SetStreamingManagerViewSource");

	Params::BGUWCStreamingFuncLib_SetStreamingManagerViewSource Parms{};

	Parms.ViewLocation = std::move(ViewLocation);
	Parms.Duration = Duration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.SpawnStreamingSource
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::SpawnStreamingSource(class UObject* WorldContext, const struct FVector& SpawnLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "SpawnStreamingSource");

	Params::BGUWCStreamingFuncLib_SpawnStreamingSource Parms{};

	Parms.WorldContext = WorldContext;
	Parms.SpawnLocation = std::move(SpawnLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.UnregisterFromStreamingSource
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::UnregisterFromStreamingSource(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "UnregisterFromStreamingSource");

	Params::BGUWCStreamingFuncLib_UnregisterFromStreamingSource Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUWCStreamingFuncLib.UpdateStreamingState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBlockTillComplete                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUWCStreamingFuncLib::UpdateStreamingState(class UObject* WorldContext, bool bBlockTillComplete)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUWCStreamingFuncLib", "UpdateStreamingState");

	Params::BGUWCStreamingFuncLib_UpdateStreamingState Parms{};

	Parms.WorldContext = WorldContext;
	Parms.bBlockTillComplete = bBlockTillComplete;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.USharpPerfTestBase.BeginPlayInCS
// (Event, Protected, BlueprintEvent)

void AUSharpPerfTestBase::BeginPlayInCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "BeginPlayInCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.USharpPerfTestBase.BoolRetTest
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   p1                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   p2                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bP3                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AUSharpPerfTestBase::BoolRetTest(int32 p1, float p2, bool bP3)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "BoolRetTest");

	Params::USharpPerfTestBase_BoolRetTest Parms{};

	Parms.p1 = p1;
	Parms.p2 = p2;
	Parms.bP3 = bP3;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.USharpPerfTestBase.EmptyCallableFunc
// (Final, Native, Protected, BlueprintCallable)

void AUSharpPerfTestBase::EmptyCallableFunc()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "EmptyCallableFunc");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.USharpPerfTestBase.EmptyCallableFuncWithParams
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   p1                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   p2                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   p3                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bP4                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AUSharpPerfTestBase::EmptyCallableFuncWithParams(int32 p1, float p2, int32 p3, bool bP4)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "EmptyCallableFuncWithParams");

	Params::USharpPerfTestBase_EmptyCallableFuncWithParams Parms{};

	Parms.p1 = p1;
	Parms.p2 = p2;
	Parms.p3 = p3;
	Parms.bP4 = bP4;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.USharpPerfTestBase.EmptyCallableFuncWithParams2
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class FName                             p1                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    p2                                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      p3                                                     (Parm, NativeAccessSpecifierPublic)

void AUSharpPerfTestBase::EmptyCallableFuncWithParams2(class FName p1, const class FString& p2, const class FText& p3)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "EmptyCallableFuncWithParams2");

	Params::USharpPerfTestBase_EmptyCallableFuncWithParams2 Parms{};

	Parms.p1 = p1;
	Parms.p2 = std::move(p2);
	Parms.p3 = std::move(p3);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.USharpPerfTestBase.IntRetTest
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// int32                                   p1                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   p2                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bP3                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Out1                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AUSharpPerfTestBase::IntRetTest(int32 p1, float p2, bool bP3, int32* Out1)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "IntRetTest");

	Params::USharpPerfTestBase_IntRetTest Parms{};

	Parms.p1 = p1;
	Parms.p2 = p2;
	Parms.bP3 = bP3;

	UObject::ProcessEvent(Func, &Parms);

	if (Out1 != nullptr)
		*Out1 = Parms.Out1;

	return Parms.ReturnValue;
}


// Function b1.USharpPerfTestBase.IntRetTest2
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   p1                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   p2                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bP3                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AUSharpPerfTestBase::IntRetTest2(int32 p1, float p2, bool bP3)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "IntRetTest2");

	Params::USharpPerfTestBase_IntRetTest2 Parms{};

	Parms.p1 = p1;
	Parms.p2 = p2;
	Parms.bP3 = bP3;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.USharpPerfTestBase.InvokeMultiDelegate
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   AttrID                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RealNewValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RealOrgValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ExpectChangeValue                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AUSharpPerfTestBase::InvokeMultiDelegate(int32 AttrID, int32 RealNewValue, int32 RealOrgValue, int32 ExpectChangeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "InvokeMultiDelegate");

	Params::USharpPerfTestBase_InvokeMultiDelegate Parms{};

	Parms.AttrID = AttrID;
	Parms.RealNewValue = RealNewValue;
	Parms.RealOrgValue = RealOrgValue;
	Parms.ExpectChangeValue = ExpectChangeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.USharpPerfTestBase.InvokeMultiDelegateNoDyn
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   AttrID                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RealNewValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RealOrgValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ExpectChangeValue                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AUSharpPerfTestBase::InvokeMultiDelegateNoDyn(int32 AttrID, int32 RealNewValue, int32 RealOrgValue, int32 ExpectChangeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "InvokeMultiDelegateNoDyn");

	Params::USharpPerfTestBase_InvokeMultiDelegateNoDyn Parms{};

	Parms.AttrID = AttrID;
	Parms.RealNewValue = RealNewValue;
	Parms.RealOrgValue = RealOrgValue;
	Parms.ExpectChangeValue = ExpectChangeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.USharpPerfTestBase.StructAsClassCreate
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   RawValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FUSharpTestStructAsClass         ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FUSharpTestStructAsClass AUSharpPerfTestBase::StructAsClassCreate(int32 RawValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "StructAsClassCreate");

	Params::USharpPerfTestBase_StructAsClassCreate Parms{};

	Parms.RawValue = RawValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.USharpPerfTestBase.StructAsClassGetInt
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FUSharpTestStructAsClass&  InVal                                                  (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AUSharpPerfTestBase::StructAsClassGetInt(const struct FUSharpTestStructAsClass& InVal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "StructAsClassGetInt");

	Params::USharpPerfTestBase_StructAsClassGetInt Parms{};

	Parms.InVal = std::move(InVal);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.USharpPerfTestBase.TestFastFuncExport
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   p1                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   p2                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   p3                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bP4                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AUSharpPerfTestBase::TestFastFuncExport(int32 p1, float p2, int32 p3, bool bP4)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "TestFastFuncExport");

	Params::USharpPerfTestBase_TestFastFuncExport Parms{};

	Parms.p1 = p1;
	Parms.p2 = p2;
	Parms.p3 = p3;
	Parms.bP4 = bP4;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.USharpPerfTestBase.TickInCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AUSharpPerfTestBase::TickInCS(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("USharpPerfTestBase", "TickInCS");

	Params::USharpPerfTestBase_TickInCS Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGULocalFluid2DComponent.GetPressureDivergenceTexture
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// class UTextureRenderTarget2D*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTextureRenderTarget2D* UBGULocalFluid2DComponent::GetPressureDivergenceTexture()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGULocalFluid2DComponent", "GetPressureDivergenceTexture");

	Params::BGULocalFluid2DComponent_GetPressureDivergenceTexture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGULocalFluid2DComponent.GetVeloDensityTexture
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// class UTextureRenderTarget2D*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTextureRenderTarget2D* UBGULocalFluid2DComponent::GetVeloDensityTexture()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGULocalFluid2DComponent", "GetVeloDensityTexture");

	Params::BGULocalFluid2DComponent_GetVeloDensityTexture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUPerformerActor.SetOptimizeEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUPerformerActor::SetOptimizeEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPerformerActor", "SetOptimizeEnabled");

	Params::BGUPerformerActor_SetOptimizeEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlacedEditorUtilityBase.ClearActorSelectionSet
// (Final, Native, Public, BlueprintCallable)

void ABGUPlacedEditorUtilityBase::ClearActorSelectionSet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "ClearActorSelectionSet");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlacedEditorUtilityBase.GetActorReference
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FString&                    PathToActor                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* ABGUPlacedEditorUtilityBase::GetActorReference(const class FString& PathToActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "GetActorReference");

	Params::BGUPlacedEditorUtilityBase_GetActorReference Parms{};

	Parms.PathToActor = std::move(PathToActor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUPlacedEditorUtilityBase.GetLevelViewportCameraInfo
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector*                         CameraLocation                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        CameraRotation                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUPlacedEditorUtilityBase::GetLevelViewportCameraInfo(struct FVector* CameraLocation, struct FRotator* CameraRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "GetLevelViewportCameraInfo");

	Params::BGUPlacedEditorUtilityBase_GetLevelViewportCameraInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (CameraLocation != nullptr)
		*CameraLocation = std::move(Parms.CameraLocation);

	if (CameraRotation != nullptr)
		*CameraRotation = std::move(Parms.CameraRotation);

	return Parms.ReturnValue;
}


// Function b1.BGUPlacedEditorUtilityBase.GetSelectionSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> ABGUPlacedEditorUtilityBase::GetSelectionSet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "GetSelectionSet");

	Params::BGUPlacedEditorUtilityBase_GetSelectionSet Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUPlacedEditorUtilityBase.OnWorldCleanup
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    SessionEnded                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    CleanupResources                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUPlacedEditorUtilityBase::OnWorldCleanup(class UWorld* World, bool SessionEnded, bool CleanupResources)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "OnWorldCleanup");

	Params::BGUPlacedEditorUtilityBase_OnWorldCleanup Parms{};

	Parms.World = World;
	Parms.SessionEnded = SessionEnded;
	Parms.CleanupResources = CleanupResources;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUPlacedEditorUtilityBase.SelectNothing
// (Final, Native, Public, BlueprintCallable)

void ABGUPlacedEditorUtilityBase::SelectNothing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "SelectNothing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlacedEditorUtilityBase.SetActorSelectionState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldBeSelected                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUPlacedEditorUtilityBase::SetActorSelectionState(class AActor* Actor, bool bShouldBeSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "SetActorSelectionState");

	Params::BGUPlacedEditorUtilityBase_SetActorSelectionState Parms{};

	Parms.Actor = Actor;
	Parms.bShouldBeSelected = bShouldBeSelected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlacedEditorUtilityBase.SetLevelViewportCameraInfo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   CameraLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  CameraRotation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABGUPlacedEditorUtilityBase::SetLevelViewportCameraInfo(const struct FVector& CameraLocation, const struct FRotator& CameraRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlacedEditorUtilityBase", "SetLevelViewportCameraInfo");

	Params::BGUPlacedEditorUtilityBase_SetLevelViewportCameraInfo Parms{};

	Parms.CameraLocation = std::move(CameraLocation);
	Parms.CameraRotation = std::move(CameraRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.DisableAllScreenMessages
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldCtx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::DisableAllScreenMessages(class UObject* WorldCtx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "DisableAllScreenMessages");

	Params::U3DebugUtil_DisableAllScreenMessages Parms{};

	Parms.WorldCtx = WorldCtx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Base                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   X                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Y                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawCircle(const class UWorld* InWorld, const struct FVector& Base, const struct FVector& X, const struct FVector& Y, const struct FColor& Color, float Radius, int32 NumSides, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawCircle");

	Params::U3DebugUtil_U3DrawCircle Parms{};

	Parms.InWorld = InWorld;
	Parms.Base = std::move(Base);
	Parms.X = std::move(X);
	Parms.Y = std::move(Y);
	Parms.Color = std::move(Color);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebug2DDonut
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMatrix&                   TransformMatrix                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   InnerRadius                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OuterRadius                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebug2DDonut(const class UWorld* InWorld, const struct FMatrix& TransformMatrix, float InnerRadius, float OuterRadius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebug2DDonut");

	Params::U3DebugUtil_U3DrawDebug2DDonut Parms{};

	Parms.InWorld = InWorld;
	Parms.TransformMatrix = std::move(TransformMatrix);
	Parms.InnerRadius = InnerRadius;
	Parms.OuterRadius = OuterRadius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugAltCone
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Origin                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Length                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleWidth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleHeight                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    DrawColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugAltCone(const class UWorld* InWorld, const struct FVector& Origin, const struct FRotator& Rotation, float Length, float AngleWidth, float AngleHeight, const struct FColor& DrawColor, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugAltCone");

	Params::U3DebugUtil_U3DrawDebugAltCone Parms{};

	Parms.InWorld = InWorld;
	Parms.Origin = std::move(Origin);
	Parms.Rotation = std::move(Rotation);
	Parms.Length = Length;
	Parms.AngleWidth = AngleWidth;
	Parms.AngleHeight = AngleHeight;
	Parms.DrawColor = std::move(DrawColor);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugBox
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugBox(const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugBox");

	Params::U3DebugUtil_U3DrawDebugBox Parms{};

	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugBox2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugBox2(const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FQuat& Rotation, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugBox2");

	Params::U3DebugUtil_U3DrawDebugBox2 Parms{};

	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Rotation = std::move(Rotation);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCamera
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   FOVDeg                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCamera(const class UWorld* InWorld, const struct FVector& Location, const struct FRotator& Rotation, float FOVDeg, float Scale, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCamera");

	Params::U3DebugUtil_U3DrawDebugCamera Parms{};

	Parms.InWorld = InWorld;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.FOVDeg = FOVDeg;
	Parms.Scale = Scale;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvas2DBox
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBox2D&                    Box                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            LineThickness                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvas2DBox(class UCanvas* Canvas, const struct FBox2D& Box, const struct FLinearColor& LineColor, const float& LineThickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvas2DBox");

	Params::U3DebugUtil_U3DrawDebugCanvas2DBox Parms{};

	Parms.Canvas = Canvas;
	Parms.Box = std::move(Box);
	Parms.LineColor = std::move(LineColor);
	Parms.LineThickness = LineThickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvas2DCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            LineThickness                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvas2DCircle(class UCanvas* Canvas, const struct FVector2D& Center, float Radius, int32 NumSides, const struct FLinearColor& LineColor, const float& LineThickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvas2DCircle");

	Params::U3DebugUtil_U3DrawDebugCanvas2DCircle Parms{};

	Parms.Canvas = Canvas;
	Parms.Center = std::move(Center);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;
	Parms.LineColor = std::move(LineColor);
	Parms.LineThickness = LineThickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvas2DLine
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvas2DLine(class UCanvas* Canvas, const struct FVector& Start, const struct FVector& End, const struct FLinearColor& LineColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvas2DLine");

	Params::U3DebugUtil_U3DrawDebugCanvas2DLine Parms{};

	Parms.Canvas = Canvas;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.LineColor = std::move(LineColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvas2DLine2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 StartPosition                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 EndPosition                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            LineThickness                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvas2DLine2(class UCanvas* Canvas, const struct FVector2D& StartPosition, const struct FVector2D& EndPosition, const struct FLinearColor& LineColor, const float& LineThickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvas2DLine2");

	Params::U3DebugUtil_U3DrawDebugCanvas2DLine2 Parms{};

	Parms.Canvas = Canvas;
	Parms.StartPosition = std::move(StartPosition);
	Parms.EndPosition = std::move(EndPosition);
	Parms.LineColor = std::move(LineColor);
	Parms.LineThickness = LineThickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvasCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Base                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   X                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Y                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvasCircle(class UCanvas* Canvas, const struct FVector& Base, const struct FVector& X, const struct FVector& Y, const struct FColor& Color, float Radius, int32 NumSides)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvasCircle");

	Params::U3DebugUtil_U3DrawDebugCanvasCircle Parms{};

	Parms.Canvas = Canvas;
	Parms.Base = std::move(Base);
	Parms.X = std::move(X);
	Parms.Y = std::move(Y);
	Parms.Color = std::move(Color);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvasLine
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvasLine(class UCanvas* Canvas, const struct FVector& Start, const struct FVector& End, const struct FLinearColor& LineColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvasLine");

	Params::U3DebugUtil_U3DrawDebugCanvasLine Parms{};

	Parms.Canvas = Canvas;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.LineColor = std::move(LineColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvasWireCone
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ConeRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ConeAngle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ConeSides                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvasWireCone(class UCanvas* Canvas, const struct FTransform& Transform, float ConeRadius, float ConeAngle, int32 ConeSides, const struct FColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvasWireCone");

	Params::U3DebugUtil_U3DrawDebugCanvasWireCone Parms{};

	Parms.Canvas = Canvas;
	Parms.Transform = std::move(Transform);
	Parms.ConeRadius = ConeRadius;
	Parms.ConeAngle = ConeAngle;
	Parms.ConeSides = ConeSides;
	Parms.Color = std::move(Color);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCanvasWireSphere
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Base                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCanvasWireSphere(class UCanvas* Canvas, const struct FVector& Base, const struct FColor& Color, float Radius, int32 NumSides)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCanvasWireSphere");

	Params::U3DebugUtil_U3DrawDebugCanvasWireSphere Parms{};

	Parms.Canvas = Canvas;
	Parms.Base = std::move(Base);
	Parms.Color = std::move(Color);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCapsule
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HalfHeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCapsule(const class UWorld* InWorld, const struct FVector& Center, float HalfHeight, float Radius, const struct FQuat& Rotation, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCapsule");

	Params::U3DebugUtil_U3DrawDebugCapsule Parms{};

	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.HalfHeight = HalfHeight;
	Parms.Radius = Radius;
	Parms.Rotation = std::move(Rotation);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMatrix&                   TransformMatrix                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawAxis                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCircle(const class UWorld* InWorld, const struct FMatrix& TransformMatrix, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness, bool bDrawAxis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCircle");

	Params::U3DebugUtil_U3DrawDebugCircle Parms{};

	Parms.InWorld = InWorld;
	Parms.TransformMatrix = std::move(TransformMatrix);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;
	Parms.bDrawAxis = bDrawAxis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCircle2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   YAxis                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ZAxis                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawAxis                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCircle2(const class UWorld* InWorld, const struct FVector& Center, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness, const struct FVector& YAxis, const struct FVector& ZAxis, bool bDrawAxis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCircle2");

	Params::U3DebugUtil_U3DrawDebugCircle2 Parms{};

	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;
	Parms.YAxis = std::move(YAxis);
	Parms.ZAxis = std::move(ZAxis);
	Parms.bDrawAxis = bDrawAxis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCone
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Origin                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Length                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleWidth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleHeight                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCone(const class UWorld* InWorld, const struct FVector& Origin, const struct FVector& Direction, float Length, float AngleWidth, float AngleHeight, int32 NumSides, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCone");

	Params::U3DebugUtil_U3DrawDebugCone Parms{};

	Parms.InWorld = InWorld;
	Parms.Origin = std::move(Origin);
	Parms.Direction = std::move(Direction);
	Parms.Length = Length;
	Parms.AngleWidth = AngleWidth;
	Parms.AngleHeight = AngleHeight;
	Parms.NumSides = NumSides;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCoordinateSystem
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AxisLoc                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  AxisRot                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCoordinateSystem(const class UWorld* InWorld, const struct FVector& AxisLoc, const struct FRotator& AxisRot, float Scale, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCoordinateSystem");

	Params::U3DebugUtil_U3DrawDebugCoordinateSystem Parms{};

	Parms.InWorld = InWorld;
	Parms.AxisLoc = std::move(AxisLoc);
	Parms.AxisRot = std::move(AxisRot);
	Parms.Scale = Scale;
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCrosshairs
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AxisLoc                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  AxisRot                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCrosshairs(const class UWorld* InWorld, const struct FVector& AxisLoc, const struct FRotator& AxisRot, float Scale, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCrosshairs");

	Params::U3DebugUtil_U3DrawDebugCrosshairs Parms{};

	Parms.InWorld = InWorld;
	Parms.AxisLoc = std::move(AxisLoc);
	Parms.AxisRot = std::move(AxisRot);
	Parms.Scale = Scale;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugCylinder
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugCylinder(const class UWorld* InWorld, const struct FVector& Start, const struct FVector& End, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugCylinder");

	Params::U3DebugUtil_U3DrawDebugCylinder Parms{};

	Parms.InWorld = InWorld;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugDirectionalArrow
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ArrowSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugDirectionalArrow(const class UWorld* InWorld, const struct FVector& LineStart, const struct FVector& LineEnd, float ArrowSize, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugDirectionalArrow");

	Params::U3DebugUtil_U3DrawDebugDirectionalArrow Parms{};

	Parms.InWorld = InWorld;
	Parms.LineStart = std::move(LineStart);
	Parms.LineEnd = std::move(LineEnd);
	Parms.ArrowSize = ArrowSize;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugFrustum
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMatrix&                   FrustumToWorld                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugFrustum(const class UWorld* InWorld, const struct FMatrix& FrustumToWorld, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugFrustum");

	Params::U3DebugUtil_U3DrawDebugFrustum Parms{};

	Parms.InWorld = InWorld;
	Parms.FrustumToWorld = std::move(FrustumToWorld);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugLine
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugLine(const class UWorld* InWorld, const struct FVector& LineStart, const struct FVector& LineEnd, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugLine");

	Params::U3DebugUtil_U3DrawDebugLine Parms{};

	Parms.InWorld = InWorld;
	Parms.LineStart = std::move(LineStart);
	Parms.LineEnd = std::move(LineEnd);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugMesh
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           Verts                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    Indices                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugMesh(const class UWorld* InWorld, const TArray<struct FVector>& Verts, const TArray<int32>& Indices, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugMesh");

	Params::U3DebugUtil_U3DrawDebugMesh Parms{};

	Parms.InWorld = InWorld;
	Parms.Verts = std::move(Verts);
	Parms.Indices = std::move(Indices);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugPoint
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   position                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    PointColor                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugPoint(const class UWorld* InWorld, const struct FVector& position, float Size, const struct FColor& PointColor, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugPoint");

	Params::U3DebugUtil_U3DrawDebugPoint Parms{};

	Parms.InWorld = InWorld;
	Parms.position = std::move(position);
	Parms.Size = Size;
	Parms.PointColor = std::move(PointColor);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugSolidBox
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBox&                      Box                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugSolidBox(const class UWorld* InWorld, const struct FBox& Box, const struct FColor& Color, const struct FTransform& Transform, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugSolidBox");

	Params::U3DebugUtil_U3DrawDebugSolidBox Parms{};

	Parms.InWorld = InWorld;
	Parms.Box = std::move(Box);
	Parms.Color = std::move(Color);
	Parms.Transform = std::move(Transform);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugSolidBox2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugSolidBox2(const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugSolidBox2");

	Params::U3DebugUtil_U3DrawDebugSolidBox2 Parms{};

	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugSolidBox3
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugSolidBox3(const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FQuat& Rotation, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugSolidBox3");

	Params::U3DebugUtil_U3DrawDebugSolidBox3 Parms{};

	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Rotation = std::move(Rotation);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugSolidPlane
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlane&                    P                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Loc                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugSolidPlane(const class UWorld* InWorld, const struct FPlane& P, const struct FVector& Loc, float Size, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugSolidPlane");

	Params::U3DebugUtil_U3DrawDebugSolidPlane Parms{};

	Parms.InWorld = InWorld;
	Parms.P = std::move(P);
	Parms.Loc = std::move(Loc);
	Parms.Size = Size;
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugSolidPlane2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlane&                    P                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Loc                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 Extents                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugSolidPlane2(const class UWorld* InWorld, const struct FPlane& P, const struct FVector& Loc, const struct FVector2D& Extents, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugSolidPlane2");

	Params::U3DebugUtil_U3DrawDebugSolidPlane2 Parms{};

	Parms.InWorld = InWorld;
	Parms.P = std::move(P);
	Parms.Loc = std::move(Loc);
	Parms.Extents = std::move(Extents);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugSphere
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugSphere(const class UWorld* InWorld, const struct FVector& Center, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugSphere");

	Params::U3DebugUtil_U3DrawDebugSphere Parms{};

	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3DrawDebugString
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TextLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Text                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TestBaseActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    TextColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawShadow                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FontScale                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3DrawDebugString(const class UWorld* InWorld, const struct FVector& TextLocation, const class FString& Text, class AActor* TestBaseActor, const struct FColor& TextColor, float Duration, bool bDrawShadow, float FontScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3DrawDebugString");

	Params::U3DebugUtil_U3DrawDebugString Parms{};

	Parms.InWorld = InWorld;
	Parms.TextLocation = std::move(TextLocation);
	Parms.Text = std::move(Text);
	Parms.TestBaseActor = TestBaseActor;
	Parms.TextColor = std::move(TextColor);
	Parms.Duration = Duration;
	Parms.bDrawShadow = bDrawShadow;
	Parms.FontScale = FontScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3FlushDebugStrings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3FlushDebugStrings(const class UWorld* InWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3FlushDebugStrings");

	Params::U3DebugUtil_U3FlushDebugStrings Parms{};

	Parms.InWorld = InWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.U3DebugUtil.U3FlushPersistentDebugLines
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UU3DebugUtil::U3FlushPersistentDebugLines(const class UWorld* InWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("U3DebugUtil", "U3FlushPersistentDebugLines");

	Params::U3DebugUtil_U3FlushPersistentDebugLines Parms{};

	Parms.InWorld = InWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlayMontageCallbackProxy.CreateProxyObjectForPlayMontage
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   ReqIdx                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBGUPlayMontageCallbackProxy*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBGUPlayMontageCallbackProxy* UBGUPlayMontageCallbackProxy::CreateProxyObjectForPlayMontage(int32 ReqIdx, class UAnimMontage* MontageToPlay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUPlayMontageCallbackProxy", "CreateProxyObjectForPlayMontage");

	Params::BGUPlayMontageCallbackProxy_CreateProxyObjectForPlayMontage Parms{};

	Parms.ReqIdx = ReqIdx;
	Parms.MontageToPlay = MontageToPlay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUPlayMontageCallbackProxy.OnMontageBlendingOut
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUPlayMontageCallbackProxy::OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlayMontageCallbackProxy", "OnMontageBlendingOut");

	Params::BGUPlayMontageCallbackProxy_OnMontageBlendingOut Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlayMontageCallbackProxy.OnMontageEnded
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUPlayMontageCallbackProxy::OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlayMontageCallbackProxy", "OnMontageEnded");

	Params::BGUPlayMontageCallbackProxy_OnMontageEnded Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlayMontageCallbackProxy.OnNotifyBeginReceived
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBranchingPointNotifyPayload&BranchingPointNotifyPayload                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UBGUPlayMontageCallbackProxy::OnNotifyBeginReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlayMontageCallbackProxy", "OnNotifyBeginReceived");

	Params::BGUPlayMontageCallbackProxy_OnNotifyBeginReceived Parms{};

	Parms.NotifyName = NotifyName;
	Parms.BranchingPointNotifyPayload = std::move(BranchingPointNotifyPayload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlayMontageCallbackProxy.OnNotifyEndReceived
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBranchingPointNotifyPayload&BranchingPointNotifyPayload                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UBGUPlayMontageCallbackProxy::OnNotifyEndReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlayMontageCallbackProxy", "OnNotifyEndReceived");

	Params::BGUPlayMontageCallbackProxy_OnNotifyEndReceived Parms{};

	Parms.NotifyName = NotifyName;
	Parms.BranchingPointNotifyPayload = std::move(BranchingPointNotifyPayload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUPlayMontageCallbackProxy.PlayMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           InSkeletalMeshComponent                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PlayRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StartingPosition                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSnapShot                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       StartingSection                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       ExceptAdditiveSlot                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUPlayMontageCallbackProxy::PlayMontage(class USkeletalMeshComponent* InSkeletalMeshComponent, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, bool bSnapShot, const class FName StartingSection, const class FName ExceptAdditiveSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUPlayMontageCallbackProxy", "PlayMontage");

	Params::BGUPlayMontageCallbackProxy_PlayMontage Parms{};

	Parms.InSkeletalMeshComponent = InSkeletalMeshComponent;
	Parms.MontageToPlay = MontageToPlay;
	Parms.PlayRate = PlayRate;
	Parms.StartingPosition = StartingPosition;
	Parms.bSnapShot = bSnapShot;
	Parms.StartingSection = StartingSection;
	Parms.ExceptAdditiveSlot = ExceptAdditiveSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGURootMotionFollowMovementComponent.GetMasterMoveComp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBGUCharacterMovementComponent*   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBGUCharacterMovementComponent* UBGURootMotionFollowMovementComponent::GetMasterMoveComp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGURootMotionFollowMovementComponent", "GetMasterMoveComp");

	Params::BGURootMotionFollowMovementComponent_GetMasterMoveComp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.X2DebugUtil.DisableAllScreenMessages
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldCtx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::DisableAllScreenMessages(class UObject* WorldCtx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "DisableAllScreenMessages");

	Params::X2DebugUtil_DisableAllScreenMessages Parms{};

	Parms.WorldCtx = WorldCtx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Base                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   X                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Y                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawCircle(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Base, const struct FVector& X, const struct FVector& Y, const struct FColor& Color, float Radius, int32 NumSides, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawCircle");

	Params::X2DebugUtil_X2DrawCircle Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Base = std::move(Base);
	Parms.X = std::move(X);
	Parms.Y = std::move(Y);
	Parms.Color = std::move(Color);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebug2DDonut
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMatrix&                   TransformMatrix                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   InnerRadius                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OuterRadius                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebug2DDonut(const bool DebugTag, const class UWorld* InWorld, const struct FMatrix& TransformMatrix, float InnerRadius, float OuterRadius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebug2DDonut");

	Params::X2DebugUtil_X2DrawDebug2DDonut Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.TransformMatrix = std::move(TransformMatrix);
	Parms.InnerRadius = InnerRadius;
	Parms.OuterRadius = OuterRadius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugAltCone
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Origin                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Length                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleWidth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleHeight                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    DrawColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugAltCone(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Origin, const struct FRotator& Rotation, float Length, float AngleWidth, float AngleHeight, const struct FColor& DrawColor, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugAltCone");

	Params::X2DebugUtil_X2DrawDebugAltCone Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Origin = std::move(Origin);
	Parms.Rotation = std::move(Rotation);
	Parms.Length = Length;
	Parms.AngleWidth = AngleWidth;
	Parms.AngleHeight = AngleHeight;
	Parms.DrawColor = std::move(DrawColor);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugBox
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugBox(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugBox");

	Params::X2DebugUtil_X2DrawDebugBox Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugBox2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugBox2(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FQuat& Rotation, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugBox2");

	Params::X2DebugUtil_X2DrawDebugBox2 Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Rotation = std::move(Rotation);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCamera
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   FOVDeg                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCamera(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Location, const struct FRotator& Rotation, float FOVDeg, float Scale, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCamera");

	Params::X2DebugUtil_X2DrawDebugCamera Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.FOVDeg = FOVDeg;
	Parms.Scale = Scale;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvas2DBox
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBox2D&                    Box                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            LineThickness                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvas2DBox(const bool DebugTag, class UCanvas* Canvas, const struct FBox2D& Box, const struct FLinearColor& LineColor, const float& LineThickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvas2DBox");

	Params::X2DebugUtil_X2DrawDebugCanvas2DBox Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.Box = std::move(Box);
	Parms.LineColor = std::move(LineColor);
	Parms.LineThickness = LineThickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvas2DCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            LineThickness                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvas2DCircle(const bool DebugTag, class UCanvas* Canvas, const struct FVector2D& Center, float Radius, int32 NumSides, const struct FLinearColor& LineColor, const float& LineThickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvas2DCircle");

	Params::X2DebugUtil_X2DrawDebugCanvas2DCircle Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.Center = std::move(Center);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;
	Parms.LineColor = std::move(LineColor);
	Parms.LineThickness = LineThickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvas2DLine
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvas2DLine(const bool DebugTag, class UCanvas* Canvas, const struct FVector& Start, const struct FVector& End, const struct FLinearColor& LineColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvas2DLine");

	Params::X2DebugUtil_X2DrawDebugCanvas2DLine Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.LineColor = std::move(LineColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvas2DLine2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 StartPosition                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 EndPosition                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            LineThickness                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvas2DLine2(const bool DebugTag, class UCanvas* Canvas, const struct FVector2D& StartPosition, const struct FVector2D& EndPosition, const struct FLinearColor& LineColor, const float& LineThickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvas2DLine2");

	Params::X2DebugUtil_X2DrawDebugCanvas2DLine2 Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.StartPosition = std::move(StartPosition);
	Parms.EndPosition = std::move(EndPosition);
	Parms.LineColor = std::move(LineColor);
	Parms.LineThickness = LineThickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvasCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Base                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   X                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Y                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvasCircle(const bool DebugTag, class UCanvas* Canvas, const struct FVector& Base, const struct FVector& X, const struct FVector& Y, const struct FColor& Color, float Radius, int32 NumSides)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvasCircle");

	Params::X2DebugUtil_X2DrawDebugCanvasCircle Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.Base = std::move(Base);
	Parms.X = std::move(X);
	Parms.Y = std::move(Y);
	Parms.Color = std::move(Color);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvasLine
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              LineColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvasLine(const bool DebugTag, class UCanvas* Canvas, const struct FVector& Start, const struct FVector& End, const struct FLinearColor& LineColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvasLine");

	Params::X2DebugUtil_X2DrawDebugCanvasLine Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.LineColor = std::move(LineColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvasWireCone
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ConeRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ConeAngle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ConeSides                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvasWireCone(const bool DebugTag, class UCanvas* Canvas, const struct FTransform& Transform, float ConeRadius, float ConeAngle, int32 ConeSides, const struct FColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvasWireCone");

	Params::X2DebugUtil_X2DrawDebugCanvasWireCone Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.Transform = std::move(Transform);
	Parms.ConeRadius = ConeRadius;
	Parms.ConeAngle = ConeAngle;
	Parms.ConeSides = ConeSides;
	Parms.Color = std::move(Color);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCanvasWireSphere
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCanvas*                          Canvas                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Base                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCanvasWireSphere(const bool DebugTag, class UCanvas* Canvas, const struct FVector& Base, const struct FColor& Color, float Radius, int32 NumSides)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCanvasWireSphere");

	Params::X2DebugUtil_X2DrawDebugCanvasWireSphere Parms{};

	Parms.DebugTag = DebugTag;
	Parms.Canvas = Canvas;
	Parms.Base = std::move(Base);
	Parms.Color = std::move(Color);
	Parms.Radius = Radius;
	Parms.NumSides = NumSides;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCapsule
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HalfHeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCapsule(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Center, float HalfHeight, float Radius, const struct FQuat& Rotation, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCapsule");

	Params::X2DebugUtil_X2DrawDebugCapsule Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.HalfHeight = HalfHeight;
	Parms.Radius = Radius;
	Parms.Rotation = std::move(Rotation);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCircle
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMatrix&                   TransformMatrix                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawAxis                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCircle(const bool DebugTag, const class UWorld* InWorld, const struct FMatrix& TransformMatrix, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness, bool bDrawAxis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCircle");

	Params::X2DebugUtil_X2DrawDebugCircle Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.TransformMatrix = std::move(TransformMatrix);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;
	Parms.bDrawAxis = bDrawAxis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCircle2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   YAxis                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ZAxis                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawAxis                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCircle2(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Center, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness, const struct FVector& YAxis, const struct FVector& ZAxis, bool bDrawAxis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCircle2");

	Params::X2DebugUtil_X2DrawDebugCircle2 Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;
	Parms.YAxis = std::move(YAxis);
	Parms.ZAxis = std::move(ZAxis);
	Parms.bDrawAxis = bDrawAxis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCone
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Origin                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Length                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleWidth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AngleHeight                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSides                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCone(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Origin, const struct FVector& Direction, float Length, float AngleWidth, float AngleHeight, int32 NumSides, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCone");

	Params::X2DebugUtil_X2DrawDebugCone Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Origin = std::move(Origin);
	Parms.Direction = std::move(Direction);
	Parms.Length = Length;
	Parms.AngleWidth = AngleWidth;
	Parms.AngleHeight = AngleHeight;
	Parms.NumSides = NumSides;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCoordinateSystem
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AxisLoc                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  AxisRot                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCoordinateSystem(const bool DebugTag, const class UWorld* InWorld, const struct FVector& AxisLoc, const struct FRotator& AxisRot, float Scale, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCoordinateSystem");

	Params::X2DebugUtil_X2DrawDebugCoordinateSystem Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.AxisLoc = std::move(AxisLoc);
	Parms.AxisRot = std::move(AxisRot);
	Parms.Scale = Scale;
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCrosshairs
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AxisLoc                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  AxisRot                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCrosshairs(const bool DebugTag, const class UWorld* InWorld, const struct FVector& AxisLoc, const struct FRotator& AxisRot, float Scale, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCrosshairs");

	Params::X2DebugUtil_X2DrawDebugCrosshairs Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.AxisLoc = std::move(AxisLoc);
	Parms.AxisRot = std::move(AxisRot);
	Parms.Scale = Scale;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugCylinder
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugCylinder(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Start, const struct FVector& End, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugCylinder");

	Params::X2DebugUtil_X2DrawDebugCylinder Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugDirectionalArrow
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ArrowSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugDirectionalArrow(const bool DebugTag, const class UWorld* InWorld, const struct FVector& LineStart, const struct FVector& LineEnd, float ArrowSize, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugDirectionalArrow");

	Params::X2DebugUtil_X2DrawDebugDirectionalArrow Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.LineStart = std::move(LineStart);
	Parms.LineEnd = std::move(LineEnd);
	Parms.ArrowSize = ArrowSize;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugFrustum
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMatrix&                   FrustumToWorld                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugFrustum(const bool DebugTag, const class UWorld* InWorld, const struct FMatrix& FrustumToWorld, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugFrustum");

	Params::X2DebugUtil_X2DrawDebugFrustum Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.FrustumToWorld = std::move(FrustumToWorld);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugLine
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LineEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugLine(const bool DebugTag, const class UWorld* InWorld, const struct FVector& LineStart, const struct FVector& LineEnd, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugLine");

	Params::X2DebugUtil_X2DrawDebugLine Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.LineStart = std::move(LineStart);
	Parms.LineEnd = std::move(LineEnd);
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugMesh
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           Verts                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    Indices                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugMesh(const bool DebugTag, const class UWorld* InWorld, const TArray<struct FVector>& Verts, const TArray<int32>& Indices, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugMesh");

	Params::X2DebugUtil_X2DrawDebugMesh Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Verts = std::move(Verts);
	Parms.Indices = std::move(Indices);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugPoint
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   position                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    PointColor                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugPoint(const bool DebugTag, const class UWorld* InWorld, const struct FVector& position, float Size, const struct FColor& PointColor, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugPoint");

	Params::X2DebugUtil_X2DrawDebugPoint Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.position = std::move(position);
	Parms.Size = Size;
	Parms.PointColor = std::move(PointColor);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugSolidBox
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBox&                      Box                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugSolidBox(const bool DebugTag, const class UWorld* InWorld, const struct FBox& Box, const struct FColor& Color, const struct FTransform& Transform, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugSolidBox");

	Params::X2DebugUtil_X2DrawDebugSolidBox Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Box = std::move(Box);
	Parms.Color = std::move(Color);
	Parms.Transform = std::move(Transform);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugSolidBox2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugSolidBox2(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugSolidBox2");

	Params::X2DebugUtil_X2DrawDebugSolidBox2 Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugSolidBox3
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Extent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugSolidBox3(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Center, const struct FVector& Extent, const struct FQuat& Rotation, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugSolidBox3");

	Params::X2DebugUtil_X2DrawDebugSolidBox3 Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Extent = std::move(Extent);
	Parms.Rotation = std::move(Rotation);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugSolidPlane
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlane&                    P                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Loc                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugSolidPlane(const bool DebugTag, const class UWorld* InWorld, const struct FPlane& P, const struct FVector& Loc, float Size, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugSolidPlane");

	Params::X2DebugUtil_X2DrawDebugSolidPlane Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.P = std::move(P);
	Parms.Loc = std::move(Loc);
	Parms.Size = Size;
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugSolidPlane2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlane&                    P                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Loc                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 Extents                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugSolidPlane2(const bool DebugTag, const class UWorld* InWorld, const struct FPlane& P, const struct FVector& Loc, const struct FVector2D& Extents, const struct FColor& Color, bool bPersistent, float LifeTime, uint8 DepthPriority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugSolidPlane2");

	Params::X2DebugUtil_X2DrawDebugSolidPlane2 Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.P = std::move(P);
	Parms.Loc = std::move(Loc);
	Parms.Extents = std::move(Extents);
	Parms.Color = std::move(Color);
	Parms.bPersistent = bPersistent;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugSphere
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Center                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistentLines                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugSphere(const bool DebugTag, const class UWorld* InWorld, const struct FVector& Center, float Radius, int32 Segments, const struct FColor& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugSphere");

	Params::X2DebugUtil_X2DrawDebugSphere Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.Center = std::move(Center);
	Parms.Radius = Radius;
	Parms.Segments = Segments;
	Parms.Color = std::move(Color);
	Parms.bPersistentLines = bPersistentLines;
	Parms.LifeTime = LifeTime;
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2DrawDebugString
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TextLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Text                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TestBaseActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    TextColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawShadow                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FontScale                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2DrawDebugString(const bool DebugTag, const class UWorld* InWorld, const struct FVector& TextLocation, const class FString& Text, class AActor* TestBaseActor, const struct FColor& TextColor, float Duration, bool bDrawShadow, float FontScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2DrawDebugString");

	Params::X2DebugUtil_X2DrawDebugString Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;
	Parms.TextLocation = std::move(TextLocation);
	Parms.Text = std::move(Text);
	Parms.TestBaseActor = TestBaseActor;
	Parms.TextColor = std::move(TextColor);
	Parms.Duration = Duration;
	Parms.bDrawShadow = bDrawShadow;
	Parms.FontScale = FontScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2FlushDebugStrings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2FlushDebugStrings(const bool DebugTag, const class UWorld* InWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2FlushDebugStrings");

	Params::X2DebugUtil_X2FlushDebugStrings Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.X2DebugUtil.X2FlushPersistentDebugLines
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const bool                              DebugTag                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UWorld*                     InWorld                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UX2DebugUtil::X2FlushPersistentDebugLines(const bool DebugTag, const class UWorld* InWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("X2DebugUtil", "X2FlushPersistentDebugLines");

	Params::X2DebugUtil_X2FlushPersistentDebugLines Parms{};

	Parms.DebugTag = DebugTag;
	Parms.InWorld = InWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGURootMotionSourceObject_Base.Init
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UCharacterMovementComponent*      MoveComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InInstanceName                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGURootMotionSourceObject_Base::Init(class UCharacterMovementComponent* MoveComp, const class FName& InInstanceName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGURootMotionSourceObject_Base", "Init");

	Params::BGURootMotionSourceObject_Base_Init Parms{};

	Parms.MoveComp = MoveComp;
	Parms.InInstanceName = InInstanceName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGURootMotionSourceObject_Base.RemoveRootMotionSource
// (Final, Native, Public, BlueprintCallable)

void UBGURootMotionSourceObject_Base::RemoveRootMotionSource()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGURootMotionSourceObject_Base", "RemoveRootMotionSource");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGURootMotionSourceObject_ConstantForce.ApplyRootMotionSource
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   WorldDirection                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAdditive                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      StrengthOverTime                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ERootMotionFinishVelocityMode           FinishVelocityMode                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   FinishSetVelocity                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FinishClampVelocity                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnableGravity                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGURootMotionSourceObject_ConstantForce::ApplyRootMotionSource(const struct FVector& WorldDirection, float Strength, float Duration, bool bIsAdditive, class UCurveFloat* StrengthOverTime, ERootMotionFinishVelocityMode FinishVelocityMode, const struct FVector& FinishSetVelocity, float FinishClampVelocity, bool bEnableGravity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGURootMotionSourceObject_ConstantForce", "ApplyRootMotionSource");

	Params::BGURootMotionSourceObject_ConstantForce_ApplyRootMotionSource Parms{};

	Parms.WorldDirection = std::move(WorldDirection);
	Parms.Strength = Strength;
	Parms.Duration = Duration;
	Parms.bIsAdditive = bIsAdditive;
	Parms.StrengthOverTime = StrengthOverTime;
	Parms.FinishVelocityMode = FinishVelocityMode;
	Parms.FinishSetVelocity = std::move(FinishSetVelocity);
	Parms.FinishClampVelocity = FinishClampVelocity;
	Parms.bEnableGravity = bEnableGravity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.BoxOverlapBGUCharacters
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxPos                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxExtent                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ABGUCharacter*>*           OutArray                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// ECollisionChannel                       QueryChannel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::BoxOverlapBGUCharacters(class UObject* WorldContextObject, const struct FVector& BoxPos, const struct FVector& BoxExtent, TArray<class ABGUCharacter*>* OutArray, ECollisionChannel QueryChannel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "BoxOverlapBGUCharacters");

	Params::BGUSelectUtil_BoxOverlapBGUCharacters Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.BoxPos = std::move(BoxPos);
	Parms.BoxExtent = std::move(BoxExtent);
	Parms.QueryChannel = QueryChannel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutArray != nullptr)
		*OutArray = std::move(Parms.OutArray);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.BoxOverlapV2BGUCharacters
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxPos                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rot                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxExtent                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ABGUCharacter*>*           OutArray                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::BoxOverlapV2BGUCharacters(class UObject* WorldContextObject, const struct FVector& BoxPos, const struct FQuat& Rot, const struct FVector& BoxExtent, TArray<class ABGUCharacter*>* OutArray)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "BoxOverlapV2BGUCharacters");

	Params::BGUSelectUtil_BoxOverlapV2BGUCharacters Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.BoxPos = std::move(BoxPos);
	Parms.Rot = std::move(Rot);
	Parms.BoxExtent = std::move(BoxExtent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutArray != nullptr)
		*OutArray = std::move(Parms.OutArray);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.GetHitUnderCursor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*                PlayerCtrl                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETraceTypeQuery                         QueryChnl                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResultSimple*                HitResult                                              (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUSelectUtil::GetHitUnderCursor(class APlayerController* PlayerCtrl, ETraceTypeQuery QueryChnl, bool bTraceComplex, struct FHitResultSimple* HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "GetHitUnderCursor");

	Params::BGUSelectUtil_GetHitUnderCursor Parms{};

	Parms.PlayerCtrl = PlayerCtrl;
	Parms.QueryChnl = QueryChnl;
	Parms.bTraceComplex = bTraceComplex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResult != nullptr)
		*HitResult = std::move(Parms.HitResult);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.LineTraceForObjects
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartTrace                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndTrace                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    bDebug                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResultSimple*                HitResult                                              (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::LineTraceForObjects(class UObject* WorldContextObject, const struct FVector& StartTrace, const struct FVector& EndTrace, const TArray<EObjectTypeQuery>& ObjectTypes, bool bDebug, struct FHitResultSimple* HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "LineTraceForObjects");

	Params::BGUSelectUtil_LineTraceForObjects Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.StartTrace = std::move(StartTrace);
	Parms.EndTrace = std::move(EndTrace);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.bDebug = bDebug;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResult != nullptr)
		*HitResult = std::move(Parms.HitResult);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.LineTraceForObjectsTypeSimple
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartTrace                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndTrace                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    bDebug                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResultSimple*                HitResult                                              (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::LineTraceForObjectsTypeSimple(class UObject* WorldContextObject, const struct FVector& StartTrace, const struct FVector& EndTrace, const TArray<EObjectTypeQuery>& ObjectTypes, bool bDebug, struct FHitResultSimple* HitResult, bool bTraceComplex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "LineTraceForObjectsTypeSimple");

	Params::BGUSelectUtil_LineTraceForObjectsTypeSimple Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.StartTrace = std::move(StartTrace);
	Parms.EndTrace = std::move(EndTrace);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.bDebug = bDebug;
	Parms.bTraceComplex = bTraceComplex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResult != nullptr)
		*HitResult = std::move(Parms.HitResult);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.LineTraceMultiByObjType
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartTrace                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndTrace                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    bDebug                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FHitResultSimple>*        HitResultList                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::LineTraceMultiByObjType(class UObject* WorldContextObject, const struct FVector& StartTrace, const struct FVector& EndTrace, const TArray<EObjectTypeQuery>& ObjectTypes, bool bDebug, TArray<struct FHitResultSimple>* HitResultList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "LineTraceMultiByObjType");

	Params::BGUSelectUtil_LineTraceMultiByObjType Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.StartTrace = std::move(StartTrace);
	Parms.EndTrace = std::move(EndTrace);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.bDebug = bDebug;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResultList != nullptr)
		*HitResultList = std::move(Parms.HitResultList);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.LineTraceOnlyCheck
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartTrace                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndTrace                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETraceTypeQuery                         QueryChnl                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDebug                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResultSimple*                HitResult                                              (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            Ingnores                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::LineTraceOnlyCheck(class UObject* WorldContextObject, const struct FVector& StartTrace, const struct FVector& EndTrace, ETraceTypeQuery QueryChnl, bool bDebug, struct FHitResultSimple* HitResult, const TArray<class AActor*>& Ingnores, bool bTraceComplex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "LineTraceOnlyCheck");

	Params::BGUSelectUtil_LineTraceOnlyCheck Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.StartTrace = std::move(StartTrace);
	Parms.EndTrace = std::move(EndTrace);
	Parms.QueryChnl = QueryChnl;
	Parms.bDebug = bDebug;
	Parms.Ingnores = std::move(Ingnores);
	Parms.bTraceComplex = bTraceComplex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResult != nullptr)
		*HitResult = std::move(Parms.HitResult);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.LineTraceSimple
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartTrace                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndTrace                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETraceTypeQuery                         QueryChnl                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDebug                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResultSimple*                HitResult                                              (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            Ingnores                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::LineTraceSimple(class UObject* WorldContextObject, const struct FVector& StartTrace, const struct FVector& EndTrace, ETraceTypeQuery QueryChnl, bool bDebug, struct FHitResultSimple* HitResult, const TArray<class AActor*>& Ingnores, bool bTraceComplex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "LineTraceSimple");

	Params::BGUSelectUtil_LineTraceSimple Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.StartTrace = std::move(StartTrace);
	Parms.EndTrace = std::move(EndTrace);
	Parms.QueryChnl = QueryChnl;
	Parms.bDebug = bDebug;
	Parms.Ingnores = std::move(Ingnores);
	Parms.bTraceComplex = bTraceComplex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResult != nullptr)
		*HitResult = std::move(Parms.HitResult);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.LineTraceSingleForObjects
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            ActorsToIgnore                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// EDrawDebugTrace                         DrawDebugType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bIgnoreSelf                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              TraceColor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              TraceHitColor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DrawTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGUSelectUtil::LineTraceSingleForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "LineTraceSingleForObjects");

	Params::BGUSelectUtil_LineTraceSingleForObjects Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.bTraceComplex = bTraceComplex;
	Parms.ActorsToIgnore = std::move(ActorsToIgnore);
	Parms.DrawDebugType = DrawDebugType;
	Parms.bIgnoreSelf = bIgnoreSelf;
	Parms.TraceColor = std::move(TraceColor);
	Parms.TraceHitColor = std::move(TraceHitColor);
	Parms.DrawTime = DrawTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutHit != nullptr)
		*OutHit = std::move(Parms.OutHit);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.MultiSphereTraceForObjects
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartTrace                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndTrace                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    bDebug                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FHitResultSimple>*        HitResultList                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::MultiSphereTraceForObjects(class UObject* WorldContextObject, const struct FVector& StartTrace, const struct FVector& EndTrace, float Radius, const TArray<EObjectTypeQuery>& ObjectTypes, bool bDebug, TArray<struct FHitResultSimple>* HitResultList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "MultiSphereTraceForObjects");

	Params::BGUSelectUtil_MultiSphereTraceForObjects Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.StartTrace = std::move(StartTrace);
	Parms.EndTrace = std::move(EndTrace);
	Parms.Radius = Radius;
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.bDebug = bDebug;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResultList != nullptr)
		*HitResultList = std::move(Parms.HitResultList);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.SelectBGUCharactersInCircle
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  OutActors                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class AActor*                           TargetBase                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TargetCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TargetFilter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<int32>&                    Params_0                                               (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::SelectBGUCharactersInCircle(class UObject* WorldContextObject, TArray<class AActor*>* OutActors, class AActor* TargetBase, int32 TargetCount, int32 TargetFilter, const TArray<int32>& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "SelectBGUCharactersInCircle");

	Params::BGUSelectUtil_SelectBGUCharactersInCircle Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetBase = TargetBase;
	Parms.TargetCount = TargetCount;
	Parms.TargetFilter = TargetFilter;
	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutActors != nullptr)
		*OutActors = std::move(Parms.OutActors);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.SelectBGUCharactersInCylinder
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  OutActors                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class AActor*                           TargetBase                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TargetCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TargetFilter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<int32>&                    Params_0                                               (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::SelectBGUCharactersInCylinder(class UObject* WorldContextObject, TArray<class AActor*>* OutActors, class AActor* TargetBase, int32 TargetCount, int32 TargetFilter, const TArray<int32>& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "SelectBGUCharactersInCylinder");

	Params::BGUSelectUtil_SelectBGUCharactersInCylinder Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetBase = TargetBase;
	Parms.TargetCount = TargetCount;
	Parms.TargetFilter = TargetFilter;
	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutActors != nullptr)
		*OutActors = std::move(Parms.OutActors);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.SelectBGUCharactersInRect
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  OutActors                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class AActor*                           TargetBase                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TargetCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TargetFilter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<int32>&                    Params_0                                               (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::SelectBGUCharactersInRect(class UObject* WorldContextObject, TArray<class AActor*>* OutActors, class AActor* TargetBase, int32 TargetCount, int32 TargetFilter, const TArray<int32>& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "SelectBGUCharactersInRect");

	Params::BGUSelectUtil_SelectBGUCharactersInRect Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetBase = TargetBase;
	Parms.TargetCount = TargetCount;
	Parms.TargetFilter = TargetFilter;
	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutActors != nullptr)
		*OutActors = std::move(Parms.OutActors);

	return Parms.ReturnValue;
}


// Function b1.BGUSelectUtil.SphereOverlapBGUCharacters
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SphereCenter                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ABGUCharacter*>*           OutArray                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// ECollisionChannel                       QueryChannel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGUSelectUtil::SphereOverlapBGUCharacters(class UObject* WorldContext, const struct FVector& SphereCenter, float Radius, TArray<class ABGUCharacter*>* OutArray, ECollisionChannel QueryChannel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGUSelectUtil", "SphereOverlapBGUCharacters");

	Params::BGUSelectUtil_SphereOverlapBGUCharacters Parms{};

	Parms.WorldContext = WorldContext;
	Parms.SphereCenter = std::move(SphereCenter);
	Parms.Radius = Radius;
	Parms.QueryChannel = QueryChannel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutArray != nullptr)
		*OutArray = std::move(Parms.OutArray);

	return Parms.ReturnValue;
}


// Function b1.BGUSpringArmComponent.BlendLocationsInCS
// (Native, Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   OriginArmLocation                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   DesiredArmLocation                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UBGUSpringArmComponent::BlendLocationsInCS(const struct FVector& OriginArmLocation, const struct FVector& DesiredArmLocation, const struct FHitResult& HitResult, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSpringArmComponent", "BlendLocationsInCS");

	Params::BGUSpringArmComponent_BlendLocationsInCS Parms{};

	Parms.OriginArmLocation = std::move(OriginArmLocation);
	Parms.DesiredArmLocation = std::move(DesiredArmLocation);
	Parms.HitResult = std::move(HitResult);
	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUSpringArmComponent.CalcSmoothLocation
// (Native, Event, Protected, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   Current                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Target                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SmoothSpeed                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UBGUSpringArmComponent::CalcSmoothLocation(const struct FVector& Current, const struct FVector& Target, float DeltaTime, const struct FVector& SmoothSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSpringArmComponent", "CalcSmoothLocation");

	Params::BGUSpringArmComponent_CalcSmoothLocation Parms{};

	Parms.Current = std::move(Current);
	Parms.Target = std::move(Target);
	Parms.DeltaTime = DeltaTime;
	Parms.SmoothSpeed = std::move(SmoothSpeed);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUSpringArmComponent.GetPreviousValues
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector*                         OutPreviousDesiredLoc                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutPreviousArmOrigin                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        OutPreviousDesiredRot                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBGUSpringArmComponent::GetPreviousValues(struct FVector* OutPreviousDesiredLoc, struct FVector* OutPreviousArmOrigin, struct FRotator* OutPreviousDesiredRot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSpringArmComponent", "GetPreviousValues");

	Params::BGUSpringArmComponent_GetPreviousValues Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutPreviousDesiredLoc != nullptr)
		*OutPreviousDesiredLoc = std::move(Parms.OutPreviousDesiredLoc);

	if (OutPreviousArmOrigin != nullptr)
		*OutPreviousArmOrigin = std::move(Parms.OutPreviousArmOrigin);

	if (OutPreviousDesiredRot != nullptr)
		*OutPreviousDesiredRot = std::move(Parms.OutPreviousDesiredRot);
}


// Function b1.BGUSpringArmComponent.ResetArmLengthLerpCache
// (Final, Native, Public, BlueprintCallable)

void UBGUSpringArmComponent::ResetArmLengthLerpCache()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSpringArmComponent", "ResetArmLengthLerpCache");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUTamerBase.ApplyWorldOffsetCS
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   InOffset                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWorldShift                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUTamerBase::ApplyWorldOffsetCS(const struct FVector& InOffset, bool bWorldShift)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "ApplyWorldOffsetCS");

	Params::BGUTamerBase_ApplyWorldOffsetCS Parms{};

	Parms.InOffset = std::move(InOffset);
	Parms.bWorldShift = bWorldShift;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUTamerBase.BeginPlayCS
// (Event, Protected, BlueprintEvent)

void ABGUTamerBase::BeginPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "BeginPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUTamerBase.ForceRefreshDetailView
// (Final, Native, Protected, BlueprintCallable)

void ABGUTamerBase::ForceRefreshDetailView()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "ForceRefreshDetailView");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUTamerBase.GetHighLODMeshConfig
// (Native, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// struct FTamerHighLODRootMeshConfig*     OutMeshConfig                                          (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUTamerBase::GetHighLODMeshConfig(struct FTamerHighLODRootMeshConfig* OutMeshConfig)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "GetHighLODMeshConfig");

	Params::BGUTamerBase_GetHighLODMeshConfig Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMeshConfig != nullptr)
		*OutMeshConfig = std::move(Parms.OutMeshConfig);

	return Parms.ReturnValue;
}


// Function b1.BGUTamerBase.OnConstructionCS
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABGUTamerBase::OnConstructionCS(const struct FTransform& Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "OnConstructionCS");

	Params::BGUTamerBase_OnConstructionCS Parms{};

	Parms.Transform = std::move(Transform);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUTamerBase.OnPostEditMove
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bFisnish                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUTamerBase::OnPostEditMove(bool bFisnish)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "OnPostEditMove");

	Params::BGUTamerBase_OnPostEditMove Parms{};

	Parms.bFisnish = bFisnish;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUTamerBase.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUTamerBase::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "OnPropertyChanged");

	Params::BGUTamerBase_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGUTamerBase.PostInitializeComponentsCS
// (Event, Protected, BlueprintEvent)

void ABGUTamerBase::PostInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "PostInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGUTamerBase.SetLODMeshVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    invisible                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGUTamerBase::SetLODMeshVisible(bool invisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "SetLODMeshVisible");

	Params::BGUTamerBase_SetLODMeshVisible Parms{};

	Parms.invisible = invisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUTamerBase.GetActorGuid
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          OutActorGuid                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUTamerBase::GetActorGuid(class FString* OutActorGuid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "GetActorGuid");

	Params::BGUTamerBase_GetActorGuid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutActorGuid != nullptr)
		*OutActorGuid = std::move(Parms.OutActorGuid);

	return Parms.ReturnValue;
}


// Function b1.BGUTamerBase.GetActorGuidCS
// (Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class FString*                          OutActorGuid                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGUTamerBase::GetActorGuidCS(class FString* OutActorGuid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTamerBase", "GetActorGuidCS");

	Params::BGUTamerBase_GetActorGuidCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (OutActorGuid != nullptr)
		*OutActorGuid = std::move(Parms.OutActorGuid);

	return Parms.ReturnValue;
}


// Function b1.BGUTeleportPoint.GetGSActorLablel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ABGUTeleportPoint::GetGSActorLablel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUTeleportPoint", "GetGSActorLablel");

	Params::BGUTeleportPoint_GetGSActorLablel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoader.AsyncLoadClass
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FSoftClassPath&            LoadPath                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBGWAssetLoaderRequest*           request                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWAssetLoader::AsyncLoadClass(const struct FSoftClassPath& LoadPath, class UBGWAssetLoaderRequest* request, int32 Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWAssetLoader", "AsyncLoadClass");

	Params::BGWAssetLoader_AsyncLoadClass Parms{};

	Parms.LoadPath = std::move(LoadPath);
	Parms.request = request;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWAssetLoader.AsyncLoadObject
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FSoftObjectPath&           LoadPath                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBGWAssetLoaderRequest*           request                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWAssetLoader::AsyncLoadObject(const struct FSoftObjectPath& LoadPath, class UBGWAssetLoaderRequest* request, int32 Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWAssetLoader", "AsyncLoadObject");

	Params::BGWAssetLoader_AsyncLoadObject Parms{};

	Parms.LoadPath = std::move(LoadPath);
	Parms.request = request;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWAssetLoader.AsyncLoadObjects
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const TArray<struct FSoftObjectPath>&   LoadList                                               (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UBGWAssetLoaderRequest*           request                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWAssetLoader::AsyncLoadObjects(const TArray<struct FSoftObjectPath>& LoadList, class UBGWAssetLoaderRequest* request, int32 Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWAssetLoader", "AsyncLoadObjects");

	Params::BGWAssetLoader_AsyncLoadObjects Parms{};

	Parms.LoadList = std::move(LoadList);
	Parms.request = request;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWAssetLoader.SyncLoadObject
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FSoftObjectPath&           Path                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UBGWAssetLoader::SyncLoadObject(const struct FSoftObjectPath& Path)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWAssetLoader", "SyncLoadObject");

	Params::BGWAssetLoader_SyncLoadObject Parms{};

	Parms.Path = std::move(Path);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoader.SyncLoadObjects
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FSoftObjectPath>&   LoadList                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UObject*>*                 outObjList                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWAssetLoader::SyncLoadObjects(const TArray<struct FSoftObjectPath>& LoadList, TArray<class UObject*>* outObjList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWAssetLoader", "SyncLoadObjects");

	Params::BGWAssetLoader_SyncLoadObjects Parms{};

	Parms.LoadList = std::move(LoadList);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outObjList != nullptr)
		*outObjList = std::move(Parms.outObjList);

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.Cancel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::Cancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "Cancel");

	Params::BGWAssetLoaderRequest_Cancel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.WaitUntilComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Timeout                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStartStalledHandles                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::WaitUntilComplete(float Timeout, bool bStartStalledHandles)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "WaitUntilComplete");

	Params::BGWAssetLoaderRequest_WaitUntilComplete Parms{};

	Parms.Timeout = Timeout;
	Parms.bStartStalledHandles = bStartStalledHandles;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.ExecuteCS
// (Event, Protected, BlueprintEvent, Const)

void UBGWAssetLoaderRequest::ExecuteCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "ExecuteCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWAssetLoaderRequest.GetDebugName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWAssetLoaderRequest::GetDebugName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "GetDebugName");

	Params::BGWAssetLoaderRequest_GetDebugName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.GetLoadedAssets
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UObject*>*                 LoadedAssets                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBGWAssetLoaderRequest::GetLoadedAssets(TArray<class UObject*>* LoadedAssets) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "GetLoadedAssets");

	Params::BGWAssetLoaderRequest_GetLoadedAssets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (LoadedAssets != nullptr)
		*LoadedAssets = std::move(Parms.LoadedAssets);
}


// Function b1.BGWAssetLoaderRequest.GetLoadedCount
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  LoadedCount                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  RequestedCount                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWAssetLoaderRequest::GetLoadedCount(int32* LoadedCount, int32* RequestedCount) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "GetLoadedCount");

	Params::BGWAssetLoaderRequest_GetLoadedCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (LoadedCount != nullptr)
		*LoadedCount = Parms.LoadedCount;

	if (RequestedCount != nullptr)
		*RequestedCount = Parms.RequestedCount;
}


// Function b1.BGWAssetLoaderRequest.GetPriority
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWAssetLoaderRequest::GetPriority() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "GetPriority");

	Params::BGWAssetLoaderRequest_GetPriority Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.GetProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBGWAssetLoaderRequest::GetProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "GetProgress");

	Params::BGWAssetLoaderRequest_GetProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.GetRequestedAssets
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FSoftObjectPath>*         AssetList                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBGWAssetLoaderRequest::GetRequestedAssets(TArray<struct FSoftObjectPath>* AssetList) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "GetRequestedAssets");

	Params::BGWAssetLoaderRequest_GetRequestedAssets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AssetList != nullptr)
		*AssetList = std::move(Parms.AssetList);
}


// Function b1.BGWAssetLoaderRequest.HasLoadCompleted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::HasLoadCompleted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "HasLoadCompleted");

	Params::BGWAssetLoaderRequest_HasLoadCompleted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.HasLoadCompletedOrStalled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::HasLoadCompletedOrStalled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "HasLoadCompletedOrStalled");

	Params::BGWAssetLoaderRequest_HasLoadCompletedOrStalled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.IsActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::IsActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "IsActive");

	Params::BGWAssetLoaderRequest_IsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.IsCombinedHandle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::IsCombinedHandle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "IsCombinedHandle");

	Params::BGWAssetLoaderRequest_IsCombinedHandle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.IsLoadingInProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::IsLoadingInProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "IsLoadingInProgress");

	Params::BGWAssetLoaderRequest_IsLoadingInProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.IsStalled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::IsStalled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "IsStalled");

	Params::BGWAssetLoaderRequest_IsStalled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWAssetLoaderRequest.WasCanceled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWAssetLoaderRequest::WasCanceled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWAssetLoaderRequest", "WasCanceled");

	Params::BGWAssetLoaderRequest_WasCanceled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWCameraGroupVolumeManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBGWCameraGroupVolumeManager*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBGWCameraGroupVolumeManager* UBGWCameraGroupVolumeManager::Get(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWCameraGroupVolumeManager", "Get");

	Params::BGWCameraGroupVolumeManager_Get Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWCppExport.GetAllFuncAsMap
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// TMap<class FString, struct FIntPtr>     ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

TMap<class FString, struct FIntPtr> UBGWCppExport::GetAllFuncAsMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWCppExport", "GetAllFuncAsMap");

	Params::BGWCppExport_GetAllFuncAsMap Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWSaveCheckDataAsset.SaveCheckCS
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class FString*                          OutTitle                                               (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutMessage                                             (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWSaveCheckDataAsset::SaveCheckCS(class FString* OutTitle, class FString* OutMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWSaveCheckDataAsset", "SaveCheckCS");

	Params::BGWSaveCheckDataAsset_SaveCheckCS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutTitle != nullptr)
		*OutTitle = std::move(Parms.OutTitle);

	if (OutMessage != nullptr)
		*OutMessage = std::move(Parms.OutMessage);

	return Parms.ReturnValue;
}


// Function b1.BGWConfigDataAsset.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWConfigDataAsset::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWConfigDataAsset", "OnPropertyChanged");

	Params::BGWConfigDataAsset_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BWC_DispLibLocalFogWrapper.SetLocalFogParameter
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FBWC_DispLibEnvSettings&   InSettings                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector2D&                 WindDir                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibLocalFogWrapper::SetLocalFogParameter(const struct FBWC_DispLibEnvSettings& InSettings, const struct FVector2D& WindDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibLocalFogWrapper", "SetLocalFogParameter");

	Params::BWC_DispLibLocalFogWrapper_SetLocalFogParameter Parms{};

	Parms.InSettings = std::move(InSettings);
	Parms.WindDir = std::move(WindDir);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.IsWeatherAvailable
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// EBGW_DispLibEnvWeather                  InWeather                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ViewLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABWC_DispLibDynamicEnvManager::IsWeatherAvailable(EBGW_DispLibEnvWeather InWeather, const struct FVector& ViewLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "IsWeatherAvailable");

	Params::BWC_DispLibDynamicEnvManager_IsWeatherAvailable Parms{};

	Parms.InWeather = InWeather;
	Parms.ViewLocation = std::move(ViewLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BWC_DispLibDynamicEnvManager.OnApplyEnvSettings
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    IsNight                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::OnApplyEnvSettings(bool IsNight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "OnApplyEnvSettings");

	Params::BWC_DispLibDynamicEnvManager_OnApplyEnvSettings Parms{};

	Parms.IsNight = IsNight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.OnLerpEnvSettings
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// float                                   Weight                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InTime                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBWC_DispLibEnvSettings&   Src                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::OnLerpEnvSettings(float Weight, float InTime, const struct FBWC_DispLibEnvSettings& Src)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "OnLerpEnvSettings");

	Params::BWC_DispLibDynamicEnvManager_OnLerpEnvSettings Parms{};

	Parms.Weight = Weight;
	Parms.InTime = InTime;
	Parms.Src = std::move(Src);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.OnTickEnvVolume
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FBWC_DispLibEnvSettings*         EnvSettings                                            (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   ViewLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InTime                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::OnTickEnvVolume(struct FBWC_DispLibEnvSettings* EnvSettings, const struct FVector& ViewLocation, float InTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "OnTickEnvVolume");

	Params::BWC_DispLibDynamicEnvManager_OnTickEnvVolume Parms{};

	Parms.ViewLocation = std::move(ViewLocation);
	Parms.InTime = InTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (EnvSettings != nullptr)
		*EnvSettings = std::move(Parms.EnvSettings);
}


// Function b1.BWC_DispLibDynamicEnvManager.OnWeatherChanged
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   CameraLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::OnWeatherChanged(const struct FVector& CameraLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "OnWeatherChanged");

	Params::BWC_DispLibDynamicEnvManager_OnWeatherChanged Parms{};

	Parms.CameraLocation = std::move(CameraLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.OverrideEnvSettings
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FBWC_DispLibEnvSettings&   Src                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FBWC_DispLibEnvSettings*         Dest                                                   (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Weight                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::OverrideEnvSettings(const struct FBWC_DispLibEnvSettings& Src, struct FBWC_DispLibEnvSettings* Dest, float Weight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "OverrideEnvSettings");

	Params::BWC_DispLibDynamicEnvManager_OverrideEnvSettings Parms{};

	Parms.Src = std::move(Src);
	Parms.Weight = Weight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Dest != nullptr)
		*Dest = std::move(Parms.Dest);
}


// Function b1.BWC_DispLibDynamicEnvManager.RandomWeather
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   ViewLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBGW_DispLibEnvWeather                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EBGW_DispLibEnvWeather ABWC_DispLibDynamicEnvManager::RandomWeather(const struct FVector& ViewLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "RandomWeather");

	Params::BWC_DispLibDynamicEnvManager_RandomWeather Parms{};

	Parms.ViewLocation = std::move(ViewLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BWC_DispLibDynamicEnvManager.SetEnvSettings
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// bool                                    IsNight                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CameraLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::SetEnvSettings(bool IsNight, const struct FVector& CameraLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "SetEnvSettings");

	Params::BWC_DispLibDynamicEnvManager_SetEnvSettings Parms{};

	Parms.IsNight = IsNight;
	Parms.CameraLocation = std::move(CameraLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.SetWeather
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBGW_DispLibEnvWeather                  InWeather                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::SetWeather(EBGW_DispLibEnvWeather InWeather)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "SetWeather");

	Params::BWC_DispLibDynamicEnvManager_SetWeather Parms{};

	Parms.InWeather = InWeather;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.SwithToNarrative
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enable                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ChangeDuration                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::SwithToNarrative(bool Enable, float ChangeDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "SwithToNarrative");

	Params::BWC_DispLibDynamicEnvManager_SwithToNarrative Parms{};

	Parms.Enable = Enable;
	Parms.ChangeDuration = ChangeDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.UpdateEnvSystemConfig
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBWS_DispLibEnvSystemConf*        SystemConf                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::UpdateEnvSystemConfig(class UBWS_DispLibEnvSystemConf* SystemConf)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "UpdateEnvSystemConfig");

	Params::BWC_DispLibDynamicEnvManager_UpdateEnvSystemConfig Parms{};

	Parms.SystemConf = SystemConf;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BWC_DispLibDynamicEnvManager.UpdateSunAndMoonAngle
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FBWC_DispLibEnvSettings&   Settings                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void ABWC_DispLibDynamicEnvManager::UpdateSunAndMoonAngle(const struct FBWC_DispLibEnvSettings& Settings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BWC_DispLibDynamicEnvManager", "UpdateSunAndMoonAngle");

	Params::BWC_DispLibDynamicEnvManager_UpdateSunAndMoonAngle Parms{};

	Parms.Settings = std::move(Settings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWAddLevelToBlackList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InLevelName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWAddLevelToBlackList(class UObject* WorldContextObject, const class FName& InLevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWAddLevelToBlackList");

	Params::BGWFunctionLibrary_BGWAddLevelToBlackList Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InLevelName = InLevelName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWAddLevelToWhiteList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InLevelName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EBGWStreamingVolumeUsage&         InUsage                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWAddLevelToWhiteList(class UObject* WorldContextObject, const class FName& InLevelName, const EBGWStreamingVolumeUsage& InUsage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWAddLevelToWhiteList");

	Params::BGWFunctionLibrary_BGWAddLevelToWhiteList Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InLevelName = InLevelName;
	Parms.InUsage = InUsage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWFindWorldInPackage
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UPackage*                         Package                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWorld*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWorld* UBGWFunctionLibrary::BGWFindWorldInPackage(class UPackage* Package)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWFindWorldInPackage");

	Params::BGWFunctionLibrary_BGWFindWorldInPackage Parms{};

	Parms.Package = Package;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWFunctionLibrary.BGWGetAllStreamingLevels
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ULevelStreaming*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ULevelStreaming*> UBGWFunctionLibrary::BGWGetAllStreamingLevels(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWGetAllStreamingLevels");

	Params::BGWFunctionLibrary_BGWGetAllStreamingLevels Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWFunctionLibrary.BGWGetAlwaysCookPathList
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UBGWFunctionLibrary::BGWGetAlwaysCookPathList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWGetAlwaysCookPathList");

	Params::BGWFunctionLibrary_BGWGetAlwaysCookPathList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWFunctionLibrary.BGWGetIsCameraMoveableWhenPaused
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWFunctionLibrary::BGWGetIsCameraMoveableWhenPaused(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWGetIsCameraMoveableWhenPaused");

	Params::BGWFunctionLibrary_BGWGetIsCameraMoveableWhenPaused Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWFunctionLibrary.BGWGetStatusChangedStreamingLevels
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<class ULevelStreaming*, struct FGSStreamingLevelLoadSetting>*OutStreamingLevels                                     (Parm, OutParm, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWGetStatusChangedStreamingLevels(class UObject* WorldContextObject, TMap<class ULevelStreaming*, struct FGSStreamingLevelLoadSetting>* OutStreamingLevels)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWGetStatusChangedStreamingLevels");

	Params::BGWFunctionLibrary_BGWGetStatusChangedStreamingLevels Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutStreamingLevels != nullptr)
		*OutStreamingLevels = std::move(Parms.OutStreamingLevels);
}


// Function b1.BGWFunctionLibrary.BGWProcessLevelStreamingVolumes
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   OverrideViewLocation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseOverrideViewLocation                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWProcessLevelStreamingVolumes(class UObject* WorldContextObject, const struct FVector& OverrideViewLocation, bool bUseOverrideViewLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWProcessLevelStreamingVolumes");

	Params::BGWFunctionLibrary_BGWProcessLevelStreamingVolumes Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.OverrideViewLocation = std::move(OverrideViewLocation);
	Parms.bUseOverrideViewLocation = bUseOverrideViewLocation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWRemoveLevelFromBlackList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InLevelName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWRemoveLevelFromBlackList(class UObject* WorldContextObject, const class FName& InLevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWRemoveLevelFromBlackList");

	Params::BGWFunctionLibrary_BGWRemoveLevelFromBlackList Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InLevelName = InLevelName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWRemoveLevelFromWhiteList
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InLevelName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWRemoveLevelFromWhiteList(class UObject* WorldContextObject, const class FName& InLevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWRemoveLevelFromWhiteList");

	Params::BGWFunctionLibrary_BGWRemoveLevelFromWhiteList Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InLevelName = InLevelName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWRequestAsyncLoad
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FSoftObjectPath>&   LoadList                                               (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// TDelegate<void()>                       CallBackDelegate                                       (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWRequestAsyncLoad(class UObject* WorldContextObject, const TArray<struct FSoftObjectPath>& LoadList, TDelegate<void()> CallBackDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWRequestAsyncLoad");

	Params::BGWFunctionLibrary_BGWRequestAsyncLoad Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LoadList = std::move(LoadList);
	Parms.CallBackDelegate = CallBackDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWSetAllLevelStreamingVolumeEnabled
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWSetAllLevelStreamingVolumeEnabled(class UObject* WorldContextObject, bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWSetAllLevelStreamingVolumeEnabled");

	Params::BGWFunctionLibrary_BGWSetAllLevelStreamingVolumeEnabled Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWSetGamePaused
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPaused                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWSetGamePaused(const class UObject* WorldContextObject, bool bPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWSetGamePaused");

	Params::BGWFunctionLibrary_BGWSetGamePaused Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bPaused = bPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.BGWSetIsCameraMoveableWhenPaused
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsCameraMoveable                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::BGWSetIsCameraMoveableWhenPaused(const class UObject* WorldContextObject, bool IsCameraMoveable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "BGWSetIsCameraMoveableWhenPaused");

	Params::BGWFunctionLibrary_BGWSetIsCameraMoveableWhenPaused Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.IsCameraMoveable = IsCameraMoveable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.GetBGWEvents
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class b1::UBGW_EventCollection*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class b1::UBGW_EventCollection* UBGWFunctionLibrary::GetBGWEvents(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "GetBGWEvents");

	Params::BGWFunctionLibrary_GetBGWEvents Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWFunctionLibrary.GetLevelStreamingAssetName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ULevelStreaming*                  LevelStreaming                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWFunctionLibrary::GetLevelStreamingAssetName(class ULevelStreaming* LevelStreaming)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "GetLevelStreamingAssetName");

	Params::BGWFunctionLibrary_GetLevelStreamingAssetName Parms{};

	Parms.LevelStreaming = LevelStreaming;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWFunctionLibrary.IsDistanceStreamingValid
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWFunctionLibrary::IsDistanceStreamingValid(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "IsDistanceStreamingValid");

	Params::BGWFunctionLibrary_IsDistanceStreamingValid Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWFunctionLibrary.MaintainVolumesContainYuanjing
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const TArray<class ABGWLevelStreamingVolume*>&InStreamingVolumes                                     (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::MaintainVolumesContainYuanjing(const TArray<class ABGWLevelStreamingVolume*>& InStreamingVolumes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "MaintainVolumesContainYuanjing");

	Params::BGWFunctionLibrary_MaintainVolumesContainYuanjing Parms{};

	Parms.InStreamingVolumes = std::move(InStreamingVolumes);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.PauseBGWVolumeLevelStreaming
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::PauseBGWVolumeLevelStreaming(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "PauseBGWVolumeLevelStreaming");

	Params::BGWFunctionLibrary_PauseBGWVolumeLevelStreaming Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.ResumeBGWVolumeLevelStreaming
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::ResumeBGWVolumeLevelStreaming(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "ResumeBGWVolumeLevelStreaming");

	Params::BGWFunctionLibrary_ResumeBGWVolumeLevelStreaming Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWFunctionLibrary.RetargetLevelStreamingLevelNames
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    sourceNames                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    destNames                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    levelPrefix                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWFunctionLibrary::RetargetLevelStreamingLevelNames(class UObject* WorldContext, const class FString& sourceNames, const class FString& destNames, const class FString& levelPrefix)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWFunctionLibrary", "RetargetLevelStreamingLevelNames");

	Params::BGWFunctionLibrary_RetargetLevelStreamingLevelNames Parms{};

	Parms.WorldContext = WorldContext;
	Parms.sourceNames = std::move(sourceNames);
	Parms.destNames = std::move(destNames);
	Parms.levelPrefix = std::move(levelPrefix);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.BeginToggleLoadingTips
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UGSInputComponent*                InputComponent                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::BeginToggleLoadingTips(class UGSInputComponent* InputComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "BeginToggleLoadingTips");

	Params::BGWGameInstance_BeginToggleLoadingTips Parms{};

	Parms.InputComponent = InputComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.CanFadeAway
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWGameInstance::CanFadeAway()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "CanFadeAway");

	Params::BGWGameInstance_CanFadeAway Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.CloseLoadingScreen
// (Final, Native, Public, BlueprintCallable)

void UBGWGameInstance::CloseLoadingScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "CloseLoadingScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.GetCurLoadingScreenState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EGSLoadingScreenState                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGSLoadingScreenState UBGWGameInstance::GetCurLoadingScreenState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetCurLoadingScreenState");

	Params::BGWGameInstance_GetCurLoadingScreenState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetCurLoadingScreenType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EGSLoadingScreenType                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGSLoadingScreenType UBGWGameInstance::GetCurLoadingScreenType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetCurLoadingScreenType");

	Params::BGWGameInstance_GetCurLoadingScreenType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetEvents
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class b1::UBGW_EventCollection*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class b1::UBGW_EventCollection* UBGWGameInstance::GetEvents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetEvents");

	Params::BGWGameInstance_GetEvents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetFirstGamePlayerForCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ULocalPlayer*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULocalPlayer* UBGWGameInstance::GetFirstGamePlayerForCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetFirstGamePlayerForCS");

	Params::BGWGameInstance_GetFirstGamePlayerForCS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetLastUseTips
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<int32>                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<int32> UBGWGameInstance::GetLastUseTips()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetLastUseTips");

	Params::BGWGameInstance_GetLastUseTips Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetOnlineSessionClassCS
// (Event, Public, BlueprintEvent)
// Parameters:
// TSubclassOf<class UOnlineSession>       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UOnlineSession> UBGWGameInstance::GetOnlineSessionClassCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetOnlineSessionClassCS");

	Params::BGWGameInstance_GetOnlineSessionClassCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetTimeInMSSinceLoadingOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

double UBGWGameInstance::GetTimeInMSSinceLoadingOpen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetTimeInMSSinceLoadingOpen");

	Params::BGWGameInstance_GetTimeInMSSinceLoadingOpen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetTravelURLForCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWGameInstance::GetTravelURLForCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetTravelURLForCS");

	Params::BGWGameInstance_GetTravelURLForCS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetTravelURLHost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWGameInstance::GetTravelURLHost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetTravelURLHost");

	Params::BGWGameInstance_GetTravelURLHost Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.GetWorldForCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWorld* UBGWGameInstance::GetWorldForCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "GetWorldForCS");

	Params::BGWGameInstance_GetWorldForCS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.IsLoadingScreenFadeAwayFinish
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWGameInstance::IsLoadingScreenFadeAwayFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "IsLoadingScreenFadeAwayFinish");

	Params::BGWGameInstance_IsLoadingScreenFadeAwayFinish Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.IsToggleLoadingTipsFinish
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWGameInstance::IsToggleLoadingTipsFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "IsToggleLoadingTipsFinish");

	Params::BGWGameInstance_IsToggleLoadingTipsFinish Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.OnGameModeMatchStateSetCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             NewMatchState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::OnGameModeMatchStateSetCS(class FName NewMatchState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "OnGameModeMatchStateSetCS");

	Params::BGWGameInstance_OnGameModeMatchStateSetCS Parms{};

	Parms.NewMatchState = NewMatchState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameInstance.OnPostActorTickCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::OnPostActorTickCS(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "OnPostActorTickCS");

	Params::BGWGameInstance_OnPostActorTickCS Parms{};

	Parms.World = World;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameInstance.OnWorldChangedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           OldWorld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWorld*                           NewWorld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::OnWorldChangedCS(class UWorld* OldWorld, class UWorld* NewWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "OnWorldChangedCS");

	Params::BGWGameInstance_OnWorldChangedCS Parms{};

	Parms.OldWorld = OldWorld;
	Parms.NewWorld = NewWorld;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameInstance.OnWorldTickStartCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::OnWorldTickStartCS(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "OnWorldTickStartCS");

	Params::BGWGameInstance_OnWorldTickStartCS Parms{};

	Parms.World = World;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameInstance.OpenLoadingScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    UseSlateThread                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EGSLoadingScreenType                    LoadingScreenType                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::OpenLoadingScreen(bool UseSlateThread, EGSLoadingScreenType LoadingScreenType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "OpenLoadingScreen");

	Params::BGWGameInstance_OpenLoadingScreen Parms{};

	Parms.UseSlateThread = UseSlateThread;
	Parms.LoadingScreenType = LoadingScreenType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.PrepareFadeAway
// (Final, Native, Public, BlueprintCallable)

void UBGWGameInstance::PrepareFadeAway()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "PrepareFadeAway");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.ProcessNianHuiLogic
// (Event, Public, BlueprintEvent)

void UBGWGameInstance::ProcessNianHuiLogic()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "ProcessNianHuiLogic");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameInstance.ReceiveTick
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TickGroup                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::ReceiveTick(float DeltaSeconds, int32 TickGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "ReceiveTick");

	Params::BGWGameInstance_ReceiveTick Parms{};

	Parms.DeltaSeconds = DeltaSeconds;
	Parms.TickGroup = TickGroup;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameInstance.ReceiveTickEvenWhenPaused
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TickGroup                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::ReceiveTickEvenWhenPaused(float DeltaSeconds, int32 TickGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "ReceiveTickEvenWhenPaused");

	Params::BGWGameInstance_ReceiveTickEvenWhenPaused Parms{};

	Parms.DeltaSeconds = DeltaSeconds;
	Parms.TickGroup = TickGroup;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameInstance.RegisterBossRushInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FBossRushInfo&             BossRushInfo                                           (Parm, NativeAccessSpecifierPublic)

void UBGWGameInstance::RegisterBossRushInfo(const struct FBossRushInfo& BossRushInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "RegisterBossRushInfo");

	Params::BGWGameInstance_RegisterBossRushInfo Parms{};

	Parms.BossRushInfo = std::move(BossRushInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.RegisterChapterInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FChapterInfo&              ChapterInfo                                            (Parm, NativeAccessSpecifierPublic)

void UBGWGameInstance::RegisterChapterInfo(const struct FChapterInfo& ChapterInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "RegisterChapterInfo");

	Params::BGWGameInstance_RegisterChapterInfo Parms{};

	Parms.ChapterInfo = std::move(ChapterInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.RegisterLoadingTipsInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FLoadingTipsInfo&          TipsInfo                                               (Parm, NativeAccessSpecifierPublic)

void UBGWGameInstance::RegisterLoadingTipsInfo(const struct FLoadingTipsInfo& TipsInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "RegisterLoadingTipsInfo");

	Params::BGWGameInstance_RegisterLoadingTipsInfo Parms{};

	Parms.TipsInfo = std::move(TipsInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.RegisterLoadingTipsMask
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UTexture2D*                       MaskTexture                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::RegisterLoadingTipsMask(class UTexture2D* MaskTexture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "RegisterLoadingTipsMask");

	Params::BGWGameInstance_RegisterLoadingTipsMask Parms{};

	Parms.MaskTexture = MaskTexture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.RequestFadeAway
// (Final, Native, Public, BlueprintCallable)

void UBGWGameInstance::RequestFadeAway()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "RequestFadeAway");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.StartGameInstanceForCS
// (Event, Public, BlueprintEvent)
// Parameters:
// EStartGameInstanceTypeForCS             StartType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::StartGameInstanceForCS(EStartGameInstanceTypeForCS StartType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "StartGameInstanceForCS");

	Params::BGWGameInstance_StartGameInstanceForCS Parms{};

	Parms.StartType = StartType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameInstance.SwitchLoadingScreenThread
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    UseSlateThread                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGameInstance::SwitchLoadingScreenThread(bool UseSlateThread)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "SwitchLoadingScreenThread");

	Params::BGWGameInstance_SwitchLoadingScreenThread Parms{};

	Parms.UseSlateThread = UseSlateThread;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameInstance.TravelURLHasHost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWGameInstance::TravelURLHasHost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "TravelURLHasHost");

	Params::BGWGameInstance_TravelURLHasHost Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameInstance.TravelURLHasOption
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Option                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWGameInstance::TravelURLHasOption(const class FString& Option)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameInstance", "TravelURLHasOption");

	Params::BGWGameInstance_TravelURLHasOption Parms{};

	Parms.Option = std::move(Option);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGameMode.BeginEndPlayCS
// (Event, Public, BlueprintEvent)
// Parameters:
// const EEndPlayReason                    EndPlayReason                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameMode::BeginEndPlayCS(const EEndPlayReason EndPlayReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "BeginEndPlayCS");

	Params::BGWGameMode_BeginEndPlayCS Parms{};

	Parms.EndPlayReason = EndPlayReason;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameMode.BeginPlayCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::BeginPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "BeginPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.GetSeamlessTravelActorListCS
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// bool                                    bToTransition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  ActorList                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void ABGWGameMode::GetSeamlessTravelActorListCS(bool bToTransition, TArray<class AActor*>* ActorList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "GetSeamlessTravelActorListCS");

	Params::BGWGameMode_GetSeamlessTravelActorListCS Parms{};

	Parms.bToTransition = bToTransition;

	UObject::ProcessEvent(Func, &Parms);

	if (ActorList != nullptr)
		*ActorList = std::move(Parms.ActorList);
}


// Function b1.BGWGameMode.HandleLeavingMapCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::HandleLeavingMapCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "HandleLeavingMapCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.HandleMatchHasStartedCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::HandleMatchHasStartedCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "HandleMatchHasStartedCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.HandleMatchIsWaitingToStartCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::HandleMatchIsWaitingToStartCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "HandleMatchIsWaitingToStartCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.HandleStartingNewPlayerCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                NewPlayer                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameMode::HandleStartingNewPlayerCS(class APlayerController* NewPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "HandleStartingNewPlayerCS");

	Params::BGWGameMode_HandleStartingNewPlayerCS Parms{};

	Parms.NewPlayer = NewPlayer;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameMode.InitGameCS
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FString&                    MapName                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Options                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          ErrorMessag                                            (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameMode::InitGameCS(const class FString& MapName, const class FString& Options, class FString* ErrorMessag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "InitGameCS");

	Params::BGWGameMode_InitGameCS Parms{};

	Parms.MapName = std::move(MapName);
	Parms.Options = std::move(Options);

	UObject::ProcessEvent(Func, &Parms);

	if (ErrorMessag != nullptr)
		*ErrorMessag = std::move(Parms.ErrorMessag);
}


// Function b1.BGWGameMode.LoginOutCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AController*                      Exiting                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameMode::LoginOutCS(class AController* Exiting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "LoginOutCS");

	Params::BGWGameMode_LoginOutCS Parms{};

	Parms.Exiting = Exiting;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameMode.PostInitializeComponentsCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::PostInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "PostInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.PostInitPropertiesCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::PostInitPropertiesCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "PostInitPropertiesCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.PostLoginCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                NewPlayer                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameMode::PostLoginCS(class APlayerController* NewPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "PostLoginCS");

	Params::BGWGameMode_PostLoginCS Parms{};

	Parms.NewPlayer = NewPlayer;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameMode.PostSeamlessTravelCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::PostSeamlessTravelCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "PostSeamlessTravelCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.PreInitializeComponentsCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::PreInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "PreInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.PreLoginCS
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FString&                    Options                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    LoginAddress                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    UniqueId                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          ErrorMessage                                           (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameMode::PreLoginCS(const class FString& Options, const class FString& LoginAddress, const class FString& UniqueId, class FString* ErrorMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "PreLoginCS");

	Params::BGWGameMode_PreLoginCS Parms{};

	Parms.Options = std::move(Options);
	Parms.LoginAddress = std::move(LoginAddress);
	Parms.UniqueId = std::move(UniqueId);

	UObject::ProcessEvent(Func, &Parms);

	if (ErrorMessage != nullptr)
		*ErrorMessage = std::move(Parms.ErrorMessage);
}


// Function b1.BGWGameMode.RestartGameCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::RestartGameCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "RestartGameCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.RestartPlayerCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class AController*                      NewPlayer                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameMode::RestartPlayerCS(class AController* NewPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "RestartPlayerCS");

	Params::BGWGameMode_RestartPlayerCS Parms{};

	Parms.NewPlayer = NewPlayer;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameMode.StartPlayCS
// (Event, Public, BlueprintEvent)

void ABGWGameMode::StartPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "StartPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameMode.IsMovieRendering
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGWGameMode::IsMovieRendering() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameMode", "IsMovieRendering");

	Params::BGWGameMode_IsMovieRendering Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGamePlayTraceObject.CanShutdown
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWGamePlayTraceObject::CanShutdown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "CanShutdown");

	Params::BGWGamePlayTraceObject_CanShutdown Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGamePlayTraceObject.GetEnableTraceing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWGamePlayTraceObject::GetEnableTraceing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "GetEnableTraceing");

	Params::BGWGamePlayTraceObject_GetEnableTraceing Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGamePlayTraceObject.OnInit
// (Final, Native, Public, BlueprintCallable)

void UBGWGamePlayTraceObject::OnInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "OnInit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGamePlayTraceObject.OnShutdown
// (Final, Native, Public, BlueprintCallable)

void UBGWGamePlayTraceObject::OnShutdown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "OnShutdown");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGamePlayTraceObject.OnTick
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGamePlayTraceObject::OnTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "OnTick");

	Params::BGWGamePlayTraceObject_OnTick Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGamePlayTraceObject.RecordFrameRate_Start
// (Final, Native, Public, BlueprintCallable)

void UBGWGamePlayTraceObject::RecordFrameRate_Start()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "RecordFrameRate_Start");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGamePlayTraceObject.RecordFrameRate_Stop
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWGamePlayTraceObject::RecordFrameRate_Stop()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "RecordFrameRate_Stop");

	Params::BGWGamePlayTraceObject_RecordFrameRate_Stop Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWGamePlayTraceObject.StartFetchTick
// (Final, Native, Public, BlueprintCallable)

void UBGWGamePlayTraceObject::StartFetchTick()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "StartFetchTick");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGamePlayTraceObject.StopFetchTick
// (Final, Native, Public, BlueprintCallable)

void UBGWGamePlayTraceObject::StopFetchTick()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "StopFetchTick");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGamePlayTraceObject.TraceEnd
// (Final, Native, Public, BlueprintCallable)

void UBGWGamePlayTraceObject::TraceEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "TraceEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGamePlayTraceObject.TraceStart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    TraceTaskName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWGamePlayTraceObject::TraceStart(const class FString& TraceTaskName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGamePlayTraceObject", "TraceStart");

	Params::BGWGamePlayTraceObject_TraceStart Parms{};

	Parms.TraceTaskName = std::move(TraceTaskName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUSimpleGamePlayTraceObject.AddTraceStatByName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUSimpleGamePlayTraceObject::AddTraceStatByName(const class FString& Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSimpleGamePlayTraceObject", "AddTraceStatByName");

	Params::BGUSimpleGamePlayTraceObject_AddTraceStatByName Parms{};

	Parms.Name_0 = std::move(Name_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUSimpleGamePlayTraceObject.FindTraceStatResult
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTraceStatResult                 ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FTraceStatResult UBGUSimpleGamePlayTraceObject::FindTraceStatResult(const class FString& Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSimpleGamePlayTraceObject", "FindTraceStatResult");

	Params::BGUSimpleGamePlayTraceObject_FindTraceStatResult Parms{};

	Parms.Name_0 = std::move(Name_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGUSimpleGamePlayTraceObject.OnInit
// (Final, Native, Public, BlueprintCallable)

void UBGUSimpleGamePlayTraceObject::OnInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSimpleGamePlayTraceObject", "OnInit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUSimpleGamePlayTraceObject.OnShutdown
// (Final, Native, Public, BlueprintCallable)

void UBGUSimpleGamePlayTraceObject::OnShutdown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSimpleGamePlayTraceObject", "OnShutdown");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGUSimpleGamePlayTraceObject.OnTick
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGUSimpleGamePlayTraceObject::OnTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGUSimpleGamePlayTraceObject", "OnTick");

	Params::BGUSimpleGamePlayTraceObject_OnTick Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWGameState.BeginPlayCS
// (Event, Public, BlueprintEvent)

void ABGWGameState::BeginPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "BeginPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameState.HandleBeginPlayCS
// (Event, Protected, BlueprintEvent)

void ABGWGameState::HandleBeginPlayCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "HandleBeginPlayCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameState.HandleLeavingMapCS
// (Event, Protected, BlueprintEvent)

void ABGWGameState::HandleLeavingMapCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "HandleLeavingMapCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameState.HandleMatchHasEndedCS
// (Event, Protected, BlueprintEvent)

void ABGWGameState::HandleMatchHasEndedCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "HandleMatchHasEndedCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameState.HandleMatchHasStartedCS
// (Event, Protected, BlueprintEvent)

void ABGWGameState::HandleMatchHasStartedCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "HandleMatchHasStartedCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameState.HandleMatchIsWaitingToStartCS
// (Event, Protected, BlueprintEvent)

void ABGWGameState::HandleMatchIsWaitingToStartCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "HandleMatchIsWaitingToStartCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameState.IsGSEventDebuggerOpenCS
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGWGameState::IsGSEventDebuggerOpenCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "IsGSEventDebuggerOpenCS");

	Params::BGWGameState_IsGSEventDebuggerOpenCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGWGameState.OnPostTickDispatchEventCS
// (Event, Public, BlueprintEvent)

void ABGWGameState::OnPostTickDispatchEventCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "OnPostTickDispatchEventCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWGameState.OnTickDispatchEventCS
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWGameState::OnTickDispatchEventCS(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "OnTickDispatchEventCS");

	Params::BGWGameState_OnTickDispatchEventCS Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWGameState.PostInitializeComponentsCS
// (Event, Public, BlueprintEvent)

void ABGWGameState::PostInitializeComponentsCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWGameState", "PostInitializeComponentsCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWLevelStreamingStateVolumeManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBGWLevelStreamingStateVolumeManager*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBGWLevelStreamingStateVolumeManager* UBGWLevelStreamingStateVolumeManager::Get(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWLevelStreamingStateVolumeManager", "Get");

	Params::BGWLevelStreamingStateVolumeManager_Get Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWLevelStreamingStateVolumeManager.UpdateCurrentActiveVolumes
// (Final, Native, Public, BlueprintCallable)

void UBGWLevelStreamingStateVolumeManager::UpdateCurrentActiveVolumes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWLevelStreamingStateVolumeManager", "UpdateCurrentActiveVolumes");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWLevelStreamingVolume.SetEnableWorldCompositionGroup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWLevelStreamingVolume::SetEnableWorldCompositionGroup(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWLevelStreamingVolume", "SetEnableWorldCompositionGroup");

	Params::BGWLevelStreamingVolume_SetEnableWorldCompositionGroup Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWObjectExtend.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWObjectExtend::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWObjectExtend", "OnPropertyChanged");

	Params::BGWObjectExtend_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineAchievement.Destroy
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineAchievement::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineAchievement.GetAllAchievements
// (Final, Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FBGWOnlineAchievementTag>*outAchievements                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineAchievement::GetAllAchievements(TArray<struct FBGWOnlineAchievementTag>* outAchievements)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "GetAllAchievements");

	Params::BGWOnlineAchievement_GetAllAchievements Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outAchievements != nullptr)
		*outAchievements = std::move(Parms.outAchievements);

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineAchievement.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineAchievement::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "Init");

	Params::BGWOnlineAchievement_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineAchievement.OnAchievementsWrittenCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineAchievement::OnAchievementsWrittenCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "OnAchievementsWrittenCompleteCS");

	Params::BGWOnlineAchievement_OnAchievementsWrittenCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineAchievement.OnQueryAchievementsCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineAchievement::OnQueryAchievementsCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "OnQueryAchievementsCompleteCS");

	Params::BGWOnlineAchievement_OnQueryAchievementsCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineAchievement.OnStatUpdatedCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineAchievement::OnStatUpdatedCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "OnStatUpdatedCompleteCS");

	Params::BGWOnlineAchievement_OnStatUpdatedCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineAchievement.ReadAchievements
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineAchievement::ReadAchievements()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "ReadAchievements");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineAchievement.ResetAchievement
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineAchievement::ResetAchievement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "ResetAchievement");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineAchievement.UpdateStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    StatName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   StatValue                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineAchievement::UpdateStat(const class FString& StatName, int32 StatValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "UpdateStat");

	Params::BGWOnlineAchievement_UpdateStat Parms{};

	Parms.StatName = std::move(StatName);
	Parms.StatValue = StatValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineAchievement.WriteAchievement
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    writeObjKey                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  writeObjValue                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineAchievement::WriteAchievement(const class FString& writeObjKey, double writeObjValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineAchievement", "WriteAchievement");

	Params::BGWOnlineAchievement_WriteAchievement Parms{};

	Parms.writeObjKey = std::move(writeObjKey);
	Parms.writeObjValue = writeObjValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineActivity.Destroy
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineActivity::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineActivity.EndActivity
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ActivityId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EOnlineActivityOutcomeType&       Outcome                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::EndActivity(const class FString& ActivityId, const EOnlineActivityOutcomeType& Outcome)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "EndActivity");

	Params::BGWOnlineActivity_EndActivity Parms{};

	Parms.ActivityId = std::move(ActivityId);
	Parms.Outcome = Outcome;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineActivity.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineActivity::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "Init");

	Params::BGWOnlineActivity_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineActivity.OnEndActivityCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::OnEndActivityCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "OnEndActivityCompleteCS");

	Params::BGWOnlineActivity_OnEndActivityCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineActivity.OnGameActivityActivationCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    ActivityId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SessionStr                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::OnGameActivityActivationCompleteCS(const class FString& ActivityId, const class FString& SessionStr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "OnGameActivityActivationCompleteCS");

	Params::BGWOnlineActivity_OnGameActivityActivationCompleteCS Parms{};

	Parms.ActivityId = std::move(ActivityId);
	Parms.SessionStr = std::move(SessionStr);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineActivity.OnResetAllActiveActivitiesCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::OnResetAllActiveActivitiesCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "OnResetAllActiveActivitiesCompleteCS");

	Params::BGWOnlineActivity_OnResetAllActiveActivitiesCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineActivity.OnResumeActivityCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::OnResumeActivityCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "OnResumeActivityCompleteCS");

	Params::BGWOnlineActivity_OnResumeActivityCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineActivity.OnSetActivityAvailabilityCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::OnSetActivityAvailabilityCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "OnSetActivityAvailabilityCompleteCS");

	Params::BGWOnlineActivity_OnSetActivityAvailabilityCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineActivity.OnSetActivityPriorityCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::OnSetActivityPriorityCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "OnSetActivityPriorityCompleteCS");

	Params::BGWOnlineActivity_OnSetActivityPriorityCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineActivity.OnStartActivityCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::OnStartActivityCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "OnStartActivityCompleteCS");

	Params::BGWOnlineActivity_OnStartActivityCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineActivity.ResetAllActiveActivities
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineActivity::ResetAllActiveActivities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "ResetAllActiveActivities");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineActivity.ResumeActivity
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ActivityId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            InProgressTasks                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class FString>&            CompletedTasks                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::ResumeActivity(const class FString& ActivityId, const TArray<class FString>& InProgressTasks, const TArray<class FString>& CompletedTasks)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "ResumeActivity");

	Params::BGWOnlineActivity_ResumeActivity Parms{};

	Parms.ActivityId = std::move(ActivityId);
	Parms.InProgressTasks = std::move(InProgressTasks);
	Parms.CompletedTasks = std::move(CompletedTasks);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineActivity.SetActivityAvailability
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ActivityId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::SetActivityAvailability(const class FString& ActivityId, bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "SetActivityAvailability");

	Params::BGWOnlineActivity_SetActivityAvailability Parms{};

	Parms.ActivityId = std::move(ActivityId);
	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineActivity.SetActivityPriority
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TMap<class FString, int32>&       PriorityMap                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::SetActivityPriority(const TMap<class FString, int32>& PriorityMap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "SetActivityPriority");

	Params::BGWOnlineActivity_SetActivityPriority Parms{};

	Parms.PriorityMap = std::move(PriorityMap);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineActivity.StartActivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ActivityId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineActivity::StartActivity(const class FString& ActivityId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineActivity", "StartActivity");

	Params::BGWOnlineActivity_StartActivity Parms{};

	Parms.ActivityId = std::move(ActivityId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSLocalPlayer.GetGameLoginOptionsCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UGSLocalPlayer::GetGameLoginOptionsCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSLocalPlayer", "GetGameLoginOptionsCS");

	Params::GSLocalPlayer_GetGameLoginOptionsCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineCloud.DeleteUserFile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCloudDelete                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLocalDelete                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineCloud::DeleteUserFile(const class FString& Filename, bool bCloudDelete, bool bLocalDelete)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "DeleteUserFile");

	Params::BGWOnlineCloud_DeleteUserFile Parms{};

	Parms.Filename = std::move(Filename);
	Parms.bCloudDelete = bCloudDelete;
	Parms.bLocalDelete = bLocalDelete;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineCloud.Destroy
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineCloud::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineCloud.EnumerateUserFiles
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineCloud::EnumerateUserFiles()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "EnumerateUserFiles");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineCloud.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineCloud::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "Init");

	Params::BGWOnlineCloud_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineCloud.OnDeleteUserFilesCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineCloud::OnDeleteUserFilesCompleteCS(const class FString& Filename, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "OnDeleteUserFilesCompleteCS");

	Params::BGWOnlineCloud_OnDeleteUserFilesCompleteCS Parms{};

	Parms.Filename = std::move(Filename);
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineCloud.OnEnumerateUserFilesCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineCloud::OnEnumerateUserFilesCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "OnEnumerateUserFilesCompleteCS");

	Params::BGWOnlineCloud_OnEnumerateUserFilesCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineCloud.OnReadUserFilesCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineCloud::OnReadUserFilesCompleteCS(const class FString& Filename, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "OnReadUserFilesCompleteCS");

	Params::BGWOnlineCloud_OnReadUserFilesCompleteCS Parms{};

	Parms.Filename = std::move(Filename);
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineCloud.OnWriteUserCloudFileCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineCloud::OnWriteUserCloudFileCompleteCS(const class FString& Filename, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "OnWriteUserCloudFileCompleteCS");

	Params::BGWOnlineCloud_OnWriteUserCloudFileCompleteCS Parms{};

	Parms.Filename = std::move(Filename);
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineCloud.ReadAllUserFiles
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineCloud::ReadAllUserFiles()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "ReadAllUserFiles");

	Params::BGWOnlineCloud_ReadAllUserFiles Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineCloud.ReadUserFile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineCloud::ReadUserFile(const class FString& Filename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "ReadUserFile");

	Params::BGWOnlineCloud_ReadUserFile Parms{};

	Parms.Filename = std::move(Filename);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineCloud.WriteUserFile
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    UserData                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UBGWOnlineCloud::WriteUserFile(const class FString& Filename, const TArray<uint8>& UserData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineCloud", "WriteUserFile");

	Params::BGWOnlineCloud_WriteUserFile Parms{};

	Parms.Filename = std::move(Filename);
	Parms.UserData = std::move(UserData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineFriend.Destroy
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineFriend::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineFriend", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineFriend.GetFriend
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ListName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineFriend::GetFriend(const class FString& ListName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineFriend", "GetFriend");

	Params::BGWOnlineFriend_GetFriend Parms{};

	Parms.ListName = std::move(ListName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineFriend.GetFriendsList
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EFriendsListsType                       ListType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FBGWOnlineFriendInfo>*    OutFriends                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineFriend::GetFriendsList(EFriendsListsType ListType, TArray<struct FBGWOnlineFriendInfo>* OutFriends)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineFriend", "GetFriendsList");

	Params::BGWOnlineFriend_GetFriendsList Parms{};

	Parms.ListType = ListType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutFriends != nullptr)
		*OutFriends = std::move(Parms.OutFriends);

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineFriend.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineFriend::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineFriend", "Init");

	Params::BGWOnlineFriend_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineFriend.OnReadFriendListCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineFriend::OnReadFriendListCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineFriend", "OnReadFriendListCompleteCS");

	Params::BGWOnlineFriend_OnReadFriendListCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineFriend.ReadFriendsList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFriendsListsType                       ListType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineFriend::ReadFriendsList(EFriendsListsType ListType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineFriend", "ReadFriendsList");

	Params::BGWOnlineFriend_ReadFriendsList Parms{};

	Parms.ListType = ListType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineIdentity.Destroy
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineIdentity::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineIdentity.GetAuthToken
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineIdentity::GetAuthToken()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "GetAuthToken");

	Params::BGWOnlineIdentity_GetAuthToken Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineIdentity.GetLinkedAccountExternalToken
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineIdentity::GetLinkedAccountExternalToken()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "GetLinkedAccountExternalToken");

	Params::BGWOnlineIdentity_GetLinkedAccountExternalToken Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineIdentity.GetUserPrivilege
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EBGWUserPrivileges                      Privilege                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineIdentity::GetUserPrivilege(EBGWUserPrivileges Privilege)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "GetUserPrivilege");

	Params::BGWOnlineIdentity_GetUserPrivilege Parms{};

	Parms.Privilege = Privilege;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineIdentity.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineIdentity::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "Init");

	Params::BGWOnlineIdentity_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineIdentity.Login
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineIdentity::Login()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "Login");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineIdentity.OnGetUserPrivilegeCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// EBGWUserPrivileges                      Privilege                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBGWPrivilegeResult                     PrivilegeResult                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineIdentity::OnGetUserPrivilegeCompleteCS(EBGWUserPrivileges Privilege, EBGWPrivilegeResult PrivilegeResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "OnGetUserPrivilegeCompleteCS");

	Params::BGWOnlineIdentity_OnGetUserPrivilegeCompleteCS Parms{};

	Parms.Privilege = Privilege;
	Parms.PrivilegeResult = PrivilegeResult;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineIdentity.OnLoginCompletedCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bSuccessful                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineIdentity::OnLoginCompletedCS(bool bSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "OnLoginCompletedCS");

	Params::BGWOnlineIdentity_OnLoginCompletedCS Parms{};

	Parms.bSuccessful = bSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineIdentity.OnRecvAntiAddictionActionCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    RecvActionsJsonStr                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineIdentity::OnRecvAntiAddictionActionCS(const class FString& RecvActionsJsonStr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "OnRecvAntiAddictionActionCS");

	Params::BGWOnlineIdentity_OnRecvAntiAddictionActionCS Parms{};

	Parms.RecvActionsJsonStr = std::move(RecvActionsJsonStr);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineIdentity.GetAuthOnlineUserId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineIdentity::GetAuthOnlineUserId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "GetAuthOnlineUserId");

	Params::BGWOnlineIdentity_GetAuthOnlineUserId Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineIdentity.GetLoginStatus
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EBGWLoginStatus                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EBGWLoginStatus UBGWOnlineIdentity::GetLoginStatus() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "GetLoginStatus");

	Params::BGWOnlineIdentity_GetLoginStatus Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineIdentity.GetPlayerNickname
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineIdentity::GetPlayerNickname() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "GetPlayerNickname");

	Params::BGWOnlineIdentity_GetPlayerNickname Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineIdentity.GetUniquePlayerId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineIdentity::GetUniquePlayerId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineIdentity", "GetUniquePlayerId");

	Params::BGWOnlineIdentity_GetUniquePlayerId Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlinePresence.Destroy
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlinePresence::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlinePresence", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlinePresence.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlinePresence::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlinePresence", "Init");

	Params::BGWOnlinePresence_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlinePresence.OnSetPresenceCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlinePresence::OnSetPresenceCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlinePresence", "OnSetPresenceCompleteCS");

	Params::BGWOnlinePresence_OnSetPresenceCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlinePresence.SetRichPresence
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    PresenceId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    StatusStr                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TMap<class FString, class FString>&Properties                                             (Parm, NativeAccessSpecifierPublic)

void UBGWOnlinePresence::SetRichPresence(const class FString& PresenceId, const class FString& StatusStr, const TMap<class FString, class FString>& Properties)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlinePresence", "SetRichPresence");

	Params::BGWOnlinePresence_SetRichPresence Parms{};

	Parms.PresenceId = std::move(PresenceId);
	Parms.StatusStr = std::move(StatusStr);
	Parms.Properties = std::move(Properties);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.CreateSession
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MaxNumPlayers                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TMap<class FName, class FString>& CustumSettings                                         (Parm, NativeAccessSpecifierPublic)
// bool                                    bIsLANMatch                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    OverrideSessionTemplate                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::CreateSession(EBGWOnlineSessionType SessionType, int32 MaxNumPlayers, const TMap<class FName, class FString>& CustumSettings, bool bIsLANMatch, const class FString& OverrideSessionTemplate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "CreateSession");

	Params::BGWOnlineSession_CreateSession Parms{};

	Parms.SessionType = SessionType;
	Parms.MaxNumPlayers = MaxNumPlayers;
	Parms.CustumSettings = std::move(CustumSettings);
	Parms.bIsLANMatch = bIsLANMatch;
	Parms.OverrideSessionTemplate = std::move(OverrideSessionTemplate);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.Destroy
// (Final, Native, Protected, BlueprintCallable)

void UBGWOnlineSession::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.DestroySession
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::DestroySession(EBGWOnlineSessionType SessionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "DestroySession");

	Params::BGWOnlineSession_DestroySession Parms{};

	Parms.SessionType = SessionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.FindSessionById
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    SessionId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsGameSession                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::FindSessionById(const class FString& SessionId, bool IsGameSession)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "FindSessionById");

	Params::BGWOnlineSession_FindSessionById Parms{};

	Parms.SessionId = std::move(SessionId);
	Parms.IsGameSession = IsGameSession;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.GetSessionIdStr
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineSession::GetSessionIdStr(EBGWOnlineSessionType SessionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "GetSessionIdStr");

	Params::BGWOnlineSession_GetSessionIdStr Parms{};

	Parms.SessionType = SessionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSession.GetSessionState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBGWOnlineSessionState                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EBGWOnlineSessionState UBGWOnlineSession::GetSessionState(EBGWOnlineSessionType SessionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "GetSessionState");

	Params::BGWOnlineSession_GetSessionState Parms{};

	Parms.SessionType = SessionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSession.GetTravelUrl
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineSession::GetTravelUrl(EBGWOnlineSessionType SessionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "GetTravelUrl");

	Params::BGWOnlineSession_GetTravelUrl Parms{};

	Parms.SessionType = SessionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSession.Init
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineSession::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "Init");

	Params::BGWOnlineSession_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSession.JoinSession
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SessionId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::JoinSession(EBGWOnlineSessionType SessionType, const class FString& SessionId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "JoinSession");

	Params::BGWOnlineSession_JoinSession Parms{};

	Parms.SessionType = SessionType;
	Parms.SessionId = std::move(SessionId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.OnCreateSessionCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    Success                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::OnCreateSessionCompleteCS(bool Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "OnCreateSessionCompleteCS");

	Params::BGWOnlineSession_OnCreateSessionCompleteCS Parms{};

	Parms.Success = Success;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSession.OnDestroySessionCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Success                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::OnDestroySessionCompleteCS(EBGWOnlineSessionType SessionType, bool Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "OnDestroySessionCompleteCS");

	Params::BGWOnlineSession_OnDestroySessionCompleteCS Parms{};

	Parms.SessionType = SessionType;
	Parms.Success = Success;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSession.OnFindSessionByIdCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    Success                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::OnFindSessionByIdCompleteCS(bool Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "OnFindSessionByIdCompleteCS");

	Params::BGWOnlineSession_OnFindSessionByIdCompleteCS Parms{};

	Parms.Success = Success;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSession.OnJoinSessionCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// EBGWJoinSessionResult                   Result                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::OnJoinSessionCompleteCS(EBGWJoinSessionResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "OnJoinSessionCompleteCS");

	Params::BGWOnlineSession_OnJoinSessionCompleteCS Parms{};

	Parms.Result = Result;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSession.OnSearchSessionsCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    Success                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::OnSearchSessionsCompleteCS(bool Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "OnSearchSessionsCompleteCS");

	Params::BGWOnlineSession_OnSearchSessionsCompleteCS Parms{};

	Parms.Success = Success;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSession.OnSessionInviteReceivedCS
// (Event, Protected, BlueprintEvent)

void UBGWOnlineSession::OnSessionInviteReceivedCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "OnSessionInviteReceivedCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWOnlineSession.OnSessionUserInviteAcceptedCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccess                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::OnSessionUserInviteAcceptedCS(bool bWasSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "OnSessionUserInviteAcceptedCS");

	Params::BGWOnlineSession_OnSessionUserInviteAcceptedCS Parms{};

	Parms.bWasSuccess = bWasSuccess;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSession.SearchSessions
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TMap<class FName, class FString>& SearchFilters                                          (Parm, NativeAccessSpecifierPublic)
// bool                                    bIsLANMatch                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::SearchSessions(EBGWOnlineSessionType SessionType, const TMap<class FName, class FString>& SearchFilters, bool bIsLANMatch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "SearchSessions");

	Params::BGWOnlineSession_SearchSessions Parms{};

	Parms.SessionType = SessionType;
	Parms.SearchFilters = std::move(SearchFilters);
	Parms.bIsLANMatch = bIsLANMatch;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.ShowFriendUI
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineSession::ShowFriendUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "ShowFriendUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSession.ShowInviteUI
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBGWOnlineSessionType                   SessionType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSession::ShowInviteUI(EBGWOnlineSessionType SessionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSession", "ShowInviteUI");

	Params::BGWOnlineSession_ShowInviteUI Parms{};

	Parms.SessionType = SessionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSubsystem.GetSubsystemType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EBGWSubsystemType                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EBGWSubsystemType UBGWOnlineSubsystem::GetSubsystemType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BGWOnlineSubsystem", "GetSubsystemType");

	Params::BGWOnlineSubsystem_GetSubsystemType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubsystem.AfterInit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineSubsystem::AfterInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "AfterInit");

	Params::BGWOnlineSubsystem_AfterInit Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubsystem.Destroy
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineSubsystem::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSubsystem.GetInstanceName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UBGWOnlineSubsystem::GetInstanceName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "GetInstanceName");

	Params::BGWOnlineSubsystem_GetInstanceName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubsystem.GetLocalPlatformName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UBGWOnlineSubsystem::GetLocalPlatformName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "GetLocalPlatformName");

	Params::BGWOnlineSubsystem_GetLocalPlatformName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubsystem.GetSubsystemNameForDebug
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UBGWOnlineSubsystem::GetSubsystemNameForDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "GetSubsystemNameForDebug");

	Params::BGWOnlineSubsystem_GetSubsystemNameForDebug Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubsystem.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBGWOnlineSubsystem::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "Init");

	Params::BGWOnlineSubsystem_Init Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubsystem.OnConnectionStatusChangedCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    Connected                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubsystem::OnConnectionStatusChangedCS(bool Connected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "OnConnectionStatusChangedCS");

	Params::BGWOnlineSubsystem_OnConnectionStatusChangedCS Parms{};

	Parms.Connected = Connected;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubsystem.OnQueryIsOwnAdditionContentCompleteCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    EntitlementId                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubsystem::OnQueryIsOwnAdditionContentCompleteCS(const class FString& EntitlementId, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "OnQueryIsOwnAdditionContentCompleteCS");

	Params::BGWOnlineSubsystem_OnQueryIsOwnAdditionContentCompleteCS Parms{};

	Parms.EntitlementId = std::move(EntitlementId);
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubsystem.OnShowStoreUIClosedCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bPurchased                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubsystem::OnShowStoreUIClosedCS(bool bPurchased)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "OnShowStoreUIClosedCS");

	Params::BGWOnlineSubsystem_OnShowStoreUIClosedCS Parms{};

	Parms.bPurchased = bPurchased;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubsystem.QueryIsOwnAdditionContent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    EntitlementId                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubsystem::QueryIsOwnAdditionContent(const class FString& EntitlementId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "QueryIsOwnAdditionContent");

	Params::BGWOnlineSubsystem_QueryIsOwnAdditionContent Parms{};

	Parms.EntitlementId = std::move(EntitlementId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSubsystem.QueryIsOwnAdditionContentSync
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    EntitlementId                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineSubsystem::QueryIsOwnAdditionContentSync(const class FString& EntitlementId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "QueryIsOwnAdditionContentSync");

	Params::BGWOnlineSubsystem_QueryIsOwnAdditionContentSync Parms{};

	Parms.EntitlementId = std::move(EntitlementId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubsystem.QueryUserNATType
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineSubsystem::QueryUserNATType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "QueryUserNATType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSubsystem.ShowStoreUI
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ProductId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    AddToCard                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineSubsystem::ShowStoreUI(const class FString& ProductId, bool AddToCard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubsystem", "ShowStoreUI");

	Params::BGWOnlineSubsystem_ShowStoreUI Parms{};

	Parms.ProductId = std::move(ProductId);
	Parms.AddToCard = AddToCard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubSystemMgr.FindGames
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsLAN                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::FindGames(bool bIsLAN)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "FindGames");

	Params::BGWOnlineSubSystemMgr_FindGames Parms{};

	Parms.bIsLAN = bIsLAN;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSubSystemMgr.HandleNetworkErrorCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ENetworkFailure                         FailureType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ErrorString                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::HandleNetworkErrorCS(class UWorld* World, ENetworkFailure FailureType, const class FString& ErrorString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "HandleNetworkErrorCS");

	Params::BGWOnlineSubSystemMgr_HandleNetworkErrorCS Parms{};

	Parms.World = World;
	Parms.FailureType = FailureType;
	Parms.ErrorString = std::move(ErrorString);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubSystemMgr.HostGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsLAN                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MaxNumPlayers                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TMap<class FString, class FString>&CustumSettings                                         (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineSubSystemMgr::HostGame(bool bIsLAN, int32 MaxNumPlayers, const TMap<class FString, class FString>& CustumSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "HostGame");

	Params::BGWOnlineSubSystemMgr_HostGame Parms{};

	Parms.bIsLAN = bIsLAN;
	Parms.MaxNumPlayers = MaxNumPlayers;
	Parms.CustumSettings = std::move(CustumSettings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubSystemMgr.JoinGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FBlueprintSearchResult&    Result                                                 (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWOnlineSubSystemMgr::JoinGame(const struct FBlueprintSearchResult& Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "JoinGame");

	Params::BGWOnlineSubSystemMgr_JoinGame Parms{};

	Parms.Result = std::move(Result);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWOnlineSubSystemMgr.LeaveGame
// (Final, Native, Public, BlueprintCallable)

void UBGWOnlineSubSystemMgr::LeaveGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "LeaveGame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWOnlineSubSystemMgr.OnCreateSessionCompleteCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             SessionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::OnCreateSessionCompleteCS(class FName SessionName, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "OnCreateSessionCompleteCS");

	Params::BGWOnlineSubSystemMgr_OnCreateSessionCompleteCS Parms{};

	Parms.SessionName = SessionName;
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubSystemMgr.OnDestroySessionCompleteCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             SessionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::OnDestroySessionCompleteCS(class FName SessionName, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "OnDestroySessionCompleteCS");

	Params::BGWOnlineSubSystemMgr_OnDestroySessionCompleteCS Parms{};

	Parms.SessionName = SessionName;
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubSystemMgr.OnFindSessionsCompleteCS
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::OnFindSessionsCompleteCS(bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "OnFindSessionsCompleteCS");

	Params::BGWOnlineSubSystemMgr_OnFindSessionsCompleteCS Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubSystemMgr.OnJoinSessionCompleteCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             SessionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Result                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::OnJoinSessionCompleteCS(class FName SessionName, int32 Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "OnJoinSessionCompleteCS");

	Params::BGWOnlineSubSystemMgr_OnJoinSessionCompleteCS Parms{};

	Parms.SessionName = SessionName;
	Parms.Result = Result;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubSystemMgr.OnStartOnlineGameCompleteCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             SessionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::OnStartOnlineGameCompleteCS(class FName SessionName, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "OnStartOnlineGameCompleteCS");

	Params::BGWOnlineSubSystemMgr_OnStartOnlineGameCompleteCS Parms{};

	Parms.SessionName = SessionName;
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWOnlineSubSystemMgr.OnUpdateSessionCompleteCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             SessionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasSuccessful                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWOnlineSubSystemMgr::OnUpdateSessionCompleteCS(class FName SessionName, bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWOnlineSubSystemMgr", "OnUpdateSessionCompleteCS");

	Params::BGWOnlineSubSystemMgr_OnUpdateSessionCompleteCS Parms{};

	Parms.SessionName = SessionName;
	Parms.bWasSuccessful = bWasSuccessful;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWPlatformEventMgr.Destroy
// (Final, Native, Protected, BlueprintCallable)

void UBGWPlatformEventMgr::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWPlatformEventMgr.Init
// (Final, Native, Protected, BlueprintCallable)

void UBGWPlatformEventMgr::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "Init");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWPlatformEventMgr.OnApplicationDeactivateCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationDeactivateCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationDeactivateCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnApplicationExitCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationExitCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationExitCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnApplicationInitCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationInitCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationInitCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnApplicationPreExitCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationPreExitCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationPreExitCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnApplicationReactivatedCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationReactivatedCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationReactivatedCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnApplicationResumeCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationResumeCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationResumeCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnApplicationSuspendCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationSuspendCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationSuspendCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnApplicationTerminateCS
// (Event, Protected, BlueprintEvent)

void UBGWPlatformEventMgr::OnApplicationTerminateCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnApplicationTerminateCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlatformEventMgr.OnNetworkInitializedChangeCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsNetworkInitialized                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWPlatformEventMgr::OnNetworkInitializedChangeCS(bool bIsNetworkInitialized)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnNetworkInitializedChangeCS");

	Params::BGWPlatformEventMgr_OnNetworkInitializedChangeCS Parms{};

	Parms.bIsNetworkInitialized = bIsNetworkInitialized;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWPlatformEventMgr.OnUserLoginChangeCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsSignIn                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PlatformUserId                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWPlatformEventMgr::OnUserLoginChangeCS(bool bIsSignIn, int32 PlatformUserId, int32 UserIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlatformEventMgr", "OnUserLoginChangeCS");

	Params::BGWPlatformEventMgr_OnUserLoginChangeCS Parms{};

	Parms.bIsSignIn = bIsSignIn;
	Parms.PlatformUserId = PlatformUserId;
	Parms.UserIndex = UserIndex;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWPlayerController.BGWDeprojectScreenToWorld
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 ScreenPosition                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         RayOrigin                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         RayDirection                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGWPlayerController::BGWDeprojectScreenToWorld(const struct FVector2D& ScreenPosition, struct FVector* RayOrigin, struct FVector* RayDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "BGWDeprojectScreenToWorld");

	Params::BGWPlayerController_BGWDeprojectScreenToWorld Parms{};

	Parms.ScreenPosition = std::move(ScreenPosition);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (RayOrigin != nullptr)
		*RayOrigin = std::move(Parms.RayOrigin);

	if (RayDirection != nullptr)
		*RayDirection = std::move(Parms.RayDirection);

	return Parms.ReturnValue;
}


// Function b1.BGWPlayerController.GetViewportClientMousePosition
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D*                       MousePosition                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGWPlayerController::GetViewportClientMousePosition(struct FVector2D* MousePosition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "GetViewportClientMousePosition");

	Params::BGWPlayerController_GetViewportClientMousePosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (MousePosition != nullptr)
		*MousePosition = std::move(Parms.MousePosition);

	return Parms.ReturnValue;
}


// Function b1.BGWPlayerController.InitCS
// (Event, Protected, BlueprintEvent)

void ABGWPlayerController::InitCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "InitCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlayerController.ProcessPlayerInputCS
// (Event, Protected, BlueprintEvent)
// Parameters:
// const float                             DeltaTime                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bGamePaused                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWPlayerController::ProcessPlayerInputCS(const float DeltaTime, const bool bGamePaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "ProcessPlayerInputCS");

	Params::BGWPlayerController_ProcessPlayerInputCS Parms{};

	Parms.DeltaTime = DeltaTime;
	Parms.bGamePaused = bGamePaused;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWPlayerController.SetupInputComponentCS
// (Event, Protected, BlueprintEvent)

void ABGWPlayerController::SetupInputComponentCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "SetupInputComponentCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWPlayerController.BGWGetHitResultAtScreenPosition
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector2D&                 ScreenPosition                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ECollisionChannel                 TraceChannel                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      HitResult                                              (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGWPlayerController::BGWGetHitResultAtScreenPosition(const struct FVector2D& ScreenPosition, const ECollisionChannel TraceChannel, bool bTraceComplex, struct FHitResult* HitResult) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "BGWGetHitResultAtScreenPosition");

	Params::BGWPlayerController_BGWGetHitResultAtScreenPosition Parms{};

	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.TraceChannel = TraceChannel;
	Parms.bTraceComplex = bTraceComplex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HitResult != nullptr)
		*HitResult = std::move(Parms.HitResult);

	return Parms.ReturnValue;
}


// Function b1.BGWPlayerController.GetPlayerInputTouch
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   Idx                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ABGWPlayerController::GetPlayerInputTouch(int32 Idx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "GetPlayerInputTouch");

	Params::BGWPlayerController_GetPlayerInputTouch Parms{};

	Parms.Idx = Idx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWPlayerController.GetPlayerInputTouchesCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABGWPlayerController::GetPlayerInputTouchesCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWPlayerController", "GetPlayerInputTouchesCount");

	Params::BGWPlayerController_GetPlayerInputTouchesCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWSplinePrismVolume.K2_EncompassesPoint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   InPoint                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutDistanceToPoint                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SphereRadius                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABGWSplinePrismVolume::K2_EncompassesPoint(const struct FVector& InPoint, float* OutDistanceToPoint, float SphereRadius) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWSplinePrismVolume", "K2_EncompassesPoint");

	Params::BGWSplinePrismVolume_K2_EncompassesPoint Parms{};

	Parms.InPoint = std::move(InPoint);
	Parms.SphereRadius = SphereRadius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDistanceToPoint != nullptr)
		*OutDistanceToPoint = Parms.OutDistanceToPoint;

	return Parms.ReturnValue;
}


// Function b1.BGWStatsCapturer.DisableCapturing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsStop                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWStatsCapturer::DisableCapturing(bool bIsStop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "DisableCapturing");

	Params::BGWStatsCapturer_DisableCapturing Parms{};

	Parms.bIsStop = bIsStop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWStatsCapturer.EnableCapturing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bTriggerLogListening                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MetricsConfigPathUnderProjDir                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWStatsCapturer::EnableCapturing(bool bTriggerLogListening, const class FString& MetricsConfigPathUnderProjDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "EnableCapturing");

	Params::BGWStatsCapturer_EnableCapturing Parms{};

	Parms.bTriggerLogListening = bTriggerLogListening;
	Parms.MetricsConfigPathUnderProjDir = std::move(MetricsConfigPathUnderProjDir);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWStatsCapturer.EnableCapturing_DT
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bTriggerLogListening                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDataTable*                       InStatDataTable                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABGWStatsCapturer::EnableCapturing_DT(bool bTriggerLogListening, class UDataTable* InStatDataTable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "EnableCapturing_DT");

	Params::BGWStatsCapturer_EnableCapturing_DT Parms{};

	Parms.bTriggerLogListening = bTriggerLogListening;
	Parms.InStatDataTable = InStatDataTable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWStatsCapturer.ExecuteRHIDumpResMemCmds
// (Final, Native, Public, BlueprintCallable)

void ABGWStatsCapturer::ExecuteRHIDumpResMemCmds()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "ExecuteRHIDumpResMemCmds");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWStatsCapturer.GetDesiredStatsValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FGSCapturedStatResult>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FGSCapturedStatResult> ABGWStatsCapturer::GetDesiredStatsValue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "GetDesiredStatsValue");

	Params::BGWStatsCapturer_GetDesiredStatsValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWStatsCapturer.GetDesiredVRAMInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FGSCapturedStatResult>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FGSCapturedStatResult> ABGWStatsCapturer::GetDesiredVRAMInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "GetDesiredVRAMInfo");

	Params::BGWStatsCapturer_GetDesiredVRAMInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWStatsCapturer.GetStartCycle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int64                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int64 ABGWStatsCapturer::GetStartCycle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "GetStartCycle");

	Params::BGWStatsCapturer_GetStartCycle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWStatsCapturer.GetTotalCapturedPerfInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FGSCapturedStatResult>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FGSCapturedStatResult> ABGWStatsCapturer::GetTotalCapturedPerfInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWStatsCapturer", "GetTotalCapturedPerfInfo");

	Params::BGWStatsCapturer_GetTotalCapturedPerfInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWVolumeManager.OnGSLevelStateChanged
// (Final, Native, Public)
// Parameters:
// int32                                   ActionID                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Linkage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWVolumeManager::OnGSLevelStateChanged(int32 ActionID, int32 Linkage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWVolumeManager", "OnGSLevelStateChanged");

	Params::BGWVolumeManager_OnGSLevelStateChanged Parms{};

	Parms.ActionID = ActionID;
	Parms.Linkage = Linkage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BGWWorldSubSystem.GetWorldRefCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWorld* UBGWWorldSubSystem::GetWorldRefCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWWorldSubSystem", "GetWorldRefCS");

	Params::BGWWorldSubSystem_GetWorldRefCS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWWorldSubSystem.OnWorldBeginPlayCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           InWorld                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWWorldSubSystem::OnWorldBeginPlayCS(class UWorld* InWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWWorldSubSystem", "OnWorldBeginPlayCS");

	Params::BGWWorldSubSystem_OnWorldBeginPlayCS Parms{};

	Parms.InWorld = InWorld;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWWorldSubSystem.OnWorldComponentsUpdatedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWWorldSubSystem::OnWorldComponentsUpdatedCS(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWWorldSubSystem", "OnWorldComponentsUpdatedCS");

	Params::BGWWorldSubSystem_OnWorldComponentsUpdatedCS Parms{};

	Parms.World = World;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWWorldSubSystem.PostInitializeCS
// (Event, Public, BlueprintEvent)

void UBGWWorldSubSystem::PostInitializeCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWWorldSubSystem", "PostInitializeCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWWorldSubSystem.DoesSupportWorldTypeCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// int32                                   WorldType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWWorldSubSystem::DoesSupportWorldTypeCS(int32 WorldType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWWorldSubSystem", "DoesSupportWorldTypeCS");

	Params::BGWWorldSubSystem_DoesSupportWorldTypeCS Parms{};

	Parms.WorldType = WorldType;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.BGWTickableWorldSubSystem.GetWorldRefCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWorld* UBGWTickableWorldSubSystem::GetWorldRefCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWTickableWorldSubSystem", "GetWorldRefCS");

	Params::BGWTickableWorldSubSystem_GetWorldRefCS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BGWTickableWorldSubSystem.OnTickCS
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWTickableWorldSubSystem::OnTickCS(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWTickableWorldSubSystem", "OnTickCS");

	Params::BGWTickableWorldSubSystem_OnTickCS Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWTickableWorldSubSystem.OnWorldBeginPlayCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           InWorld                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWTickableWorldSubSystem::OnWorldBeginPlayCS(class UWorld* InWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWTickableWorldSubSystem", "OnWorldBeginPlayCS");

	Params::BGWTickableWorldSubSystem_OnWorldBeginPlayCS Parms{};

	Parms.InWorld = InWorld;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWTickableWorldSubSystem.OnWorldComponentsUpdatedCS
// (Event, Public, BlueprintEvent)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBGWTickableWorldSubSystem::OnWorldComponentsUpdatedCS(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWTickableWorldSubSystem", "OnWorldComponentsUpdatedCS");

	Params::BGWTickableWorldSubSystem_OnWorldComponentsUpdatedCS Parms{};

	Parms.World = World;

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BGWTickableWorldSubSystem.PostInitializeCS
// (Event, Public, BlueprintEvent)

void UBGWTickableWorldSubSystem::PostInitializeCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWTickableWorldSubSystem", "PostInitializeCS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BGWTickableWorldSubSystem.DoesSupportWorldTypeCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// int32                                   WorldType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBGWTickableWorldSubSystem::DoesSupportWorldTypeCS(int32 WorldType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BGWTickableWorldSubSystem", "DoesSupportWorldTypeCS");

	Params::BGWTickableWorldSubSystem_DoesSupportWorldTypeCS Parms{};

	Parms.WorldType = WorldType;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.GSDescPropertyDetailCustomizationHelper.FindDescIdByRowName
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             RowName                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UGSDescPropertyDetailCustomizationHelper::FindDescIdByRowName(class FName RowName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSDescPropertyDetailCustomizationHelper", "FindDescIdByRowName");

	Params::GSDescPropertyDetailCustomizationHelper_FindDescIdByRowName Parms{};

	Parms.RowName = RowName;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.GSDescPropertyDetailCustomizationHelper.GetRowNameByDescId
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// int32                                   DescID                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName*                            RowName                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSDescPropertyDetailCustomizationHelper::GetRowNameByDescId(int32 DescID, class FName* RowName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSDescPropertyDetailCustomizationHelper", "GetRowNameByDescId");

	Params::GSDescPropertyDetailCustomizationHelper_GetRowNameByDescId Parms{};

	Parms.DescID = DescID;

	UObject::ProcessEvent(Func, &Parms);

	if (RowName != nullptr)
		*RowName = Parms.RowName;

	return Parms.ReturnValue;
}


// Function b1.GSDescPropertyDetailCustomizationHelper.OnGetRowStrings
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// TArray<class FString>*                  OutStrings                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<bool>*                           OutRestrictedItems                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UGSDescPropertyDetailCustomizationHelper::OnGetRowStrings(TArray<class FString>* OutStrings, TArray<bool>* OutRestrictedItems)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSDescPropertyDetailCustomizationHelper", "OnGetRowStrings");

	Params::GSDescPropertyDetailCustomizationHelper_OnGetRowStrings Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (OutStrings != nullptr)
		*OutStrings = std::move(Parms.OutStrings);

	if (OutRestrictedItems != nullptr)
		*OutRestrictedItems = std::move(Parms.OutRestrictedItems);
}


// Function b1.BTDecorator_USharpBase.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBTDecorator_USharpBase::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTDecorator_USharpBase", "OnPropertyChanged");

	Params::BTDecorator_USharpBase_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BTDecorator_USharpBase.RefreshNodeInfoInEditor
// (Event, Public, BlueprintEvent)

void UBTDecorator_USharpBase::RefreshNodeInfoInEditor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTDecorator_USharpBase", "RefreshNodeInfoInEditor");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BTDecorator_USharpBase.SetNodeNameInCS
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    NewNodeName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBTDecorator_USharpBase::SetNodeNameInCS(const class FString& NewNodeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTDecorator_USharpBase", "SetNodeNameInCS");

	Params::BTDecorator_USharpBase_SetNodeNameInCS Parms{};

	Parms.NewNodeName = std::move(NewNodeName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BTService_USharpBase.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBTService_USharpBase::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTService_USharpBase", "OnPropertyChanged");

	Params::BTService_USharpBase_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BTService_USharpBase.RefreshNodeInfoInEditor
// (Event, Public, BlueprintEvent)

void UBTService_USharpBase::RefreshNodeInfoInEditor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTService_USharpBase", "RefreshNodeInfoInEditor");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BTService_USharpBase.SetNodeNameInCS
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    NewNodeName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBTService_USharpBase::SetNodeNameInCS(const class FString& NewNodeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTService_USharpBase", "SetNodeNameInCS");

	Params::BTService_USharpBase_SetNodeNameInCS Parms{};

	Parms.NewNodeName = std::move(NewNodeName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BTService_USharpBase.IsServiceActive
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBTService_USharpBase::IsServiceActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTService_USharpBase", "IsServiceActive");

	Params::BTService_USharpBase_IsServiceActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BTTask_USharpBase.FinishAbort
// (Final, Native, Protected, BlueprintCallable)

void UBTTask_USharpBase::FinishAbort()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTTask_USharpBase", "FinishAbort");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.BTTask_USharpBase.FinishExecute
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBTTask_USharpBase::FinishExecute(bool bSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTTask_USharpBase", "FinishExecute");

	Params::BTTask_USharpBase_FinishExecute Parms{};

	Parms.bSuccess = bSuccess;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BTTask_USharpBase.OnPropertyChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBTTask_USharpBase::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTTask_USharpBase", "OnPropertyChanged");

	Params::BTTask_USharpBase_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.BTTask_USharpBase.RefreshNodeInfoInEditor
// (Event, Public, BlueprintEvent)

void UBTTask_USharpBase::RefreshNodeInfoInEditor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTTask_USharpBase", "RefreshNodeInfoInEditor");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.BTTask_USharpBase.SetNodeNameInCS
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    NewNodeName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBTTask_USharpBase::SetNodeNameInCS(const class FString& NewNodeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTTask_USharpBase", "SetNodeNameInCS");

	Params::BTTask_USharpBase_SetNodeNameInCS Parms{};

	Parms.NewNodeName = std::move(NewNodeName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BTTask_USharpBase.IsTaskAborting
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBTTask_USharpBase::IsTaskAborting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTTask_USharpBase", "IsTaskAborting");

	Params::BTTask_USharpBase_IsTaskAborting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BTTask_USharpBase.IsTaskExecuting
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBTTask_USharpBase::IsTaskExecuting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BTTask_USharpBase", "IsTaskExecuting");

	Params::BTTask_USharpBase_IsTaskExecuting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUAnimLocomotionEx.SetLocoExEnable
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IBUAnimLocomotionEx::SetLocoExEnable(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BUAnimLocomotionEx", "SetLocoExEnable");

	Params::BUAnimLocomotionEx_SetLocoExEnable Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BUAnimLocomotionEx.SetLocoExSettings
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FBUAnimSettingsLocomotionEx&Settings                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void IBUAnimLocomotionEx::SetLocoExSettings(const struct FBUAnimSettingsLocomotionEx& Settings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BUAnimLocomotionEx", "SetLocoExSettings");

	Params::BUAnimLocomotionEx_SetLocoExSettings Parms{};

	Parms.Settings = std::move(Settings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BUS_UtilComm.CalcDegreeFromRotatorsInYaw
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FRotator&                  ARotator                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  BRotator                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBUS_UtilComm::CalcDegreeFromRotatorsInYaw(const struct FRotator& ARotator, const struct FRotator& BRotator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "CalcDegreeFromRotatorsInYaw");

	Params::BUS_UtilComm_CalcDegreeFromRotatorsInYaw Parms{};

	Parms.ARotator = std::move(ARotator);
	Parms.BRotator = std::move(BRotator);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.CalcDegreeFromVectorsProjectInXYPlane
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FVector&                   AVector                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BVector                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBUS_UtilComm::CalcDegreeFromVectorsProjectInXYPlane(const struct FVector& AVector, const struct FVector& BVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "CalcDegreeFromVectorsProjectInXYPlane");

	Params::BUS_UtilComm_CalcDegreeFromVectorsProjectInXYPlane Parms{};

	Parms.AVector = std::move(AVector);
	Parms.BVector = std::move(BVector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.CalcDirWithInput
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ForwardVal                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RightVal                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UBUS_UtilComm::CalcDirWithInput(class ACharacter* CurCharacter, float ForwardVal, float RightVal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "CalcDirWithInput");

	Params::BUS_UtilComm_CalcDirWithInput Parms{};

	Parms.CurCharacter = CurCharacter;
	Parms.ForwardVal = ForwardVal;
	Parms.RightVal = RightVal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.CalcYawRotator
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   FromLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UBUS_UtilComm::CalcYawRotator(const struct FVector& TargetLocation, const struct FVector& FromLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "CalcYawRotator");

	Params::BUS_UtilComm_CalcYawRotator Parms{};

	Parms.TargetLocation = std::move(TargetLocation);
	Parms.FromLocation = std::move(FromLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.GetCurActiveMontagePos
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBUS_UtilComm::GetCurActiveMontagePos(class ACharacter* CurCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "GetCurActiveMontagePos");

	Params::BUS_UtilComm_GetCurActiveMontagePos Parms{};

	Parms.CurCharacter = CurCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.GetEasingFuncType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EGSBlendTypeG                           GSBlengTypeG                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBUS_UtilComm::GetEasingFuncType(EGSBlendTypeG GSBlengTypeG)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "GetEasingFuncType");

	Params::BUS_UtilComm_GetEasingFuncType Parms{};

	Parms.GSBlengTypeG = GSBlengTypeG;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.GetUMatineeCameraShakeBlendOutTime
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UMatineeCameraShake*              CameraShake                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBUS_UtilComm::GetUMatineeCameraShakeBlendOutTime(class UMatineeCameraShake* CameraShake)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "GetUMatineeCameraShakeBlendOutTime");

	Params::BUS_UtilComm_GetUMatineeCameraShakeBlendOutTime Parms{};

	Parms.CameraShake = CameraShake;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.GSEase
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   Start                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   End                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EGSBlendTypeG                           GSBlendTypeG                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   EaseExp                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBUS_UtilComm::GSEase(float Start, float End, float alpha, EGSBlendTypeG GSBlendTypeG, float EaseExp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "GSEase");

	Params::BUS_UtilComm_GSEase Parms{};

	Parms.Start = Start;
	Parms.End = End;
	Parms.alpha = alpha;
	Parms.GSBlendTypeG = GSBlendTypeG;
	Parms.EaseExp = EaseExp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.GSEaseRotator
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  Start                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  End                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EGSBlendTypeG                           GSBlendTypeG                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   EaseExp                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsShortestPath                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UBUS_UtilComm::GSEaseRotator(const struct FRotator& Start, const struct FRotator& End, float alpha, EGSBlendTypeG GSBlendTypeG, float EaseExp, bool IsShortestPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "GSEaseRotator");

	Params::BUS_UtilComm_GSEaseRotator Parms{};

	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.alpha = alpha;
	Parms.GSBlendTypeG = GSBlendTypeG;
	Parms.EaseExp = EaseExp;
	Parms.IsShortestPath = IsShortestPath;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.IsCharacterStoped
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBUS_UtilComm::IsCharacterStoped(class ACharacter* CurCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "IsCharacterStoped");

	Params::BUS_UtilComm_IsCharacterStoped Parms{};

	Parms.CurCharacter = CurCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.LoadAKEventFromString
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ResPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UBUS_UtilComm::LoadAKEventFromString(const class FString& ResPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "LoadAKEventFromString");

	Params::BUS_UtilComm_LoadAKEventFromString Parms{};

	Parms.ResPath = std::move(ResPath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.LoadAnimMontageFromString
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ResPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UBUS_UtilComm::LoadAnimMontageFromString(const class FString& ResPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "LoadAnimMontageFromString");

	Params::BUS_UtilComm_LoadAnimMontageFromString Parms{};

	Parms.ResPath = std::move(ResPath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.LoadCameraShakeFromString
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ResPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UClass* UBUS_UtilComm::LoadCameraShakeFromString(const class FString& ResPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "LoadCameraShakeFromString");

	Params::BUS_UtilComm_LoadCameraShakeFromString Parms{};

	Parms.ResPath = std::move(ResPath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.LoadCurveFloatFromString
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ResPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UCurveFloat* UBUS_UtilComm::LoadCurveFloatFromString(const class FString& ResPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "LoadCurveFloatFromString");

	Params::BUS_UtilComm_LoadCurveFloatFromString Parms{};

	Parms.ResPath = std::move(ResPath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.LoadLevelSequenceFromString
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ResPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULevelSequence*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULevelSequence* UBUS_UtilComm::LoadLevelSequenceFromString(const class FString& ResPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "LoadLevelSequenceFromString");

	Params::BUS_UtilComm_LoadLevelSequenceFromString Parms{};

	Parms.ResPath = std::move(ResPath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.LoadParticleSystemFromString
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ResPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DefaultDelayTime                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UParticleSystem*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UParticleSystem* UBUS_UtilComm::LoadParticleSystemFromString(const class FString& ResPath, float DefaultDelayTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "LoadParticleSystemFromString");

	Params::BUS_UtilComm_LoadParticleSystemFromString Parms{};

	Parms.ResPath = std::move(ResPath);
	Parms.DefaultDelayTime = DefaultDelayTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.ParticleSystemComponentTrailSetTimeRate
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBUS_UtilComm::ParticleSystemComponentTrailSetTimeRate(class ACharacter* CurCharacter, float TimeRate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "ParticleSystemComponentTrailSetTimeRate");

	Params::BUS_UtilComm_ParticleSystemComponentTrailSetTimeRate Parms{};

	Parms.CurCharacter = CurCharacter;
	Parms.TimeRate = TimeRate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.BUS_UtilComm.PlayCameraShakeByClass
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Caster                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           CameraShakeCls                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMatineeCameraShake*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMatineeCameraShake* UBUS_UtilComm::PlayCameraShakeByClass(class AActor* Caster, class UClass* CameraShakeCls)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "PlayCameraShakeByClass");

	Params::BUS_UtilComm_PlayCameraShakeByClass Parms{};

	Parms.Caster = Caster;
	Parms.CameraShakeCls = CameraShakeCls;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.PlayMontage
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBUS_UtilComm::PlayMontage(class ACharacter* CurCharacter, class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "PlayMontage");

	Params::BUS_UtilComm_PlayMontage Parms{};

	Parms.CurCharacter = CurCharacter;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.SafeSetCharacterMontagePlaying
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsPlaying                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBUS_UtilComm::SafeSetCharacterMontagePlaying(class ACharacter* CurCharacter, bool IsPlaying)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "SafeSetCharacterMontagePlaying");

	Params::BUS_UtilComm_SafeSetCharacterMontagePlaying Parms{};

	Parms.CurCharacter = CurCharacter;
	Parms.IsPlaying = IsPlaying;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.SafeSetCharacterMontagePlayingRate
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PlayRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBUS_UtilComm::SafeSetCharacterMontagePlayingRate(class ACharacter* CurCharacter, float PlayRate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "SafeSetCharacterMontagePlayingRate");

	Params::BUS_UtilComm_SafeSetCharacterMontagePlayingRate Parms{};

	Parms.CurCharacter = CurCharacter;
	Parms.PlayRate = PlayRate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.BUS_UtilComm.SetCurActiveMontagePos
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       CurCharacter                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TargetPos                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBUS_UtilComm::SetCurActiveMontagePos(class ACharacter* CurCharacter, float TargetPos)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BUS_UtilComm", "SetCurActiveMontagePos");

	Params::BUS_UtilComm_SetCurActiveMontagePos Parms{};

	Parms.CurCharacter = CurCharacter;
	Parms.TargetPos = TargetPos;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQTBase.GetWorkOnFloatValuesCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSEQTBase::GetWorkOnFloatValuesCS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "GetWorkOnFloatValuesCS");

	Params::GSEQTBase_GetWorkOnFloatValuesCS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function b1.GSEQTBase.OnPropertyChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// const class FString&                    MemberName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQTBase::OnPropertyChanged(const class FString& MemberName, const class FString& PropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "OnPropertyChanged");

	Params::GSEQTBase_OnPropertyChanged Parms{};

	Parms.MemberName = std::move(MemberName);
	Parms.PropertyName = std::move(PropertyName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.GSEQTBase.SetWorkOnFloatValuesCS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bWorkOnFloats                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQTBase::SetWorkOnFloatValuesCS(bool bWorkOnFloats)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "SetWorkOnFloatValuesCS");

	Params::GSEQTBase_SetWorkOnFloatValuesCS Parms{};

	Parms.bWorkOnFloats = bWorkOnFloats;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQTBase.ForceItemStateFailed
// (Final, Native, Public, BlueprintCallable, Const)

void UGSEQTBase::ForceItemStateFailed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "ForceItemStateFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQTBase.ForceItemStatePassed
// (Final, Native, Public, BlueprintCallable, Const)

void UGSEQTBase::ForceItemStatePassed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "ForceItemStatePassed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQTBase.GetDescriptionDetailsCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UGSEQTBase::GetDescriptionDetailsCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "GetDescriptionDetailsCS");

	Params::GSEQTBase_GetDescriptionDetailsCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.GSEQTBase.GetDescriptionTitleCS
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UGSEQTBase::GetDescriptionTitleCS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "GetDescriptionTitleCS");

	Params::GSEQTBase_GetDescriptionTitleCS Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.GSEQTBase.PostProcessItems
// (Event, Public, BlueprintEvent, Const)

void UGSEQTBase::PostProcessItems() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "PostProcessItems");

	UObject::ProcessEvent(Func, nullptr);
}


// Function b1.GSEQTBase.PreProcessItems
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const TArray<class AActor*>&            ContextActors                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           ContextLocations                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UGSEQTBase::PreProcessItems(const TArray<class AActor*>& ContextActors, const TArray<struct FVector>& ContextLocations) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "PreProcessItems");

	Params::GSEQTBase_PreProcessItems Parms{};

	Parms.ContextActors = std::move(ContextActors);
	Parms.ContextLocations = std::move(ContextLocations);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.GSEQTBase.ProcessCustomItemScoreCS
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const struct FGSEnvQueryTestItem&       Item                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UGSEQTBase::ProcessCustomItemScoreCS(const struct FGSEnvQueryTestItem& Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "ProcessCustomItemScoreCS");

	Params::GSEQTBase_ProcessCustomItemScoreCS Parms{};

	Parms.Item = std::move(Item);

	UObject::ProcessEvent(Func, &Parms);
}


// Function b1.GSEQTBase.ProcessItemCS
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ItemLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ItemActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Querier                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSEQTBase::ProcessItemCS(class UWorld* World, const struct FVector& ItemLocation, class AActor* ItemActor, class AActor* Querier) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "ProcessItemCS");

	Params::GSEQTBase_ProcessItemCS Parms{};

	Parms.World = World;
	Parms.ItemLocation = std::move(ItemLocation);
	Parms.ItemActor = ItemActor;
	Parms.Querier = Querier;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.GSEQTBase.SetItemScoreBool
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// bool                                    bScore                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQTBase::SetItemScoreBool(bool bScore) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "SetItemScoreBool");

	Params::GSEQTBase_SetItemScoreBool Parms{};

	Parms.bScore = bScore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQTBase.SetItemScoreFloat
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// float                                   Score                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGSEQTBase::SetItemScoreFloat(float Score) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "SetItemScoreFloat");

	Params::GSEQTBase_SetItemScoreFloat Parms{};

	Parms.Score = Score;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function b1.GSEQTBase.ShouldPrepareContext
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSEQTBase::ShouldPrepareContext() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "ShouldPrepareContext");

	Params::GSEQTBase_ShouldPrepareContext Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function b1.GSEQTBase.ShouldUseCustomItemScore
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGSEQTBase::ShouldUseCustomItemScore() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GSEQTBase", "ShouldUseCustomItemScore");

	Params::GSEQTBase_ShouldUseCustomItemScore Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}

}