#pragma once

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

// Package: PenguinHotel

#include "Basic.hpp"

#include "PenguinHotel_classes.hpp"
#include "PenguinHotel_parameters.hpp"


SDK_NAMESPACE_START

// Function PenguinHotel.ActorInViewChecker.CalculateDotProductOnCameraXYPlane
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   CameraForward                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ActorPosition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UActorInViewChecker::CalculateDotProductOnCameraXYPlane(const struct FVector& CameraForward, const struct FVector& ActorPosition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ActorInViewChecker", "CalculateDotProductOnCameraXYPlane");

	Params::ActorInViewChecker_CalculateDotProductOnCameraXYPlane Parms{};

	Parms.CameraForward = std::move(CameraForward);
	Parms.ActorPosition = std::move(ActorPosition);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ActorInViewChecker.IsActorInCameraView
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                CameraTransform                                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FieldOfView                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AspectRatio                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UActorInViewChecker::IsActorInCameraView(const struct FTransform& CameraTransform, float FieldOfView, float AspectRatio, class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ActorInViewChecker", "IsActorInCameraView");

	Params::ActorInViewChecker_IsActorInCameraView Parms{};

	Parms.CameraTransform = std::move(CameraTransform);
	Parms.FieldOfView = FieldOfView;
	Parms.AspectRatio = AspectRatio;
	Parms.TargetActor = TargetActor;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ActorInViewChecker.IsActorInCameraView_2
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                CameraTransform                                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FOV                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AspectRatio                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UActorInViewChecker::IsActorInCameraView_2(const class AActor* Actor, const struct FTransform& CameraTransform, float FOV, float AspectRatio)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ActorInViewChecker", "IsActorInCameraView_2");

	Params::ActorInViewChecker_IsActorInCameraView_2 Parms{};

	Parms.Actor = Actor;
	Parms.CameraTransform = std::move(CameraTransform);
	Parms.FOV = FOV;
	Parms.AspectRatio = AspectRatio;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ActorInViewChecker.LocalToWorldTransform
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                ParentTransform                                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FTransform>&        LocalTransforms                                        (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<struct FVector>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FVector> UActorInViewChecker::LocalToWorldTransform(const struct FTransform& ParentTransform, const TArray<struct FTransform>& LocalTransforms)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ActorInViewChecker", "LocalToWorldTransform");

	Params::ActorInViewChecker_LocalToWorldTransform Parms{};

	Parms.ParentTransform = std::move(ParentTransform);
	Parms.LocalTransforms = std::move(LocalTransforms);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.GetAvailableBandwidth
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TotalAvailableBytesPerSecOverride                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBandwidthCheckerLibrary::GetAvailableBandwidth(class UObject* WorldContextObject, float TotalAvailableBytesPerSecOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "GetAvailableBandwidth");

	Params::BandwidthCheckerLibrary_GetAvailableBandwidth Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TotalAvailableBytesPerSecOverride = TotalAvailableBytesPerSecOverride;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.GetBandwidthPerPlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBandwidthCheckerLibrary::GetBandwidthPerPlayer(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "GetBandwidthPerPlayer");

	Params::BandwidthCheckerLibrary_GetBandwidthPerPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.GetBandwidthStats
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TotalAvailableBytesPerSecOverride                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBandwidthStats                  ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FBandwidthStats UBandwidthCheckerLibrary::GetBandwidthStats(class UObject* WorldContextObject, float TotalAvailableBytesPerSecOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "GetBandwidthStats");

	Params::BandwidthCheckerLibrary_GetBandwidthStats Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TotalAvailableBytesPerSecOverride = TotalAvailableBytesPerSecOverride;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.GetBandwidthUsageRatio
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TotalAvailableBytesPerSecOverride                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBandwidthCheckerLibrary::GetBandwidthUsageRatio(class UObject* WorldContextObject, float TotalAvailableBytesPerSecOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "GetBandwidthUsageRatio");

	Params::BandwidthCheckerLibrary_GetBandwidthUsageRatio Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TotalAvailableBytesPerSecOverride = TotalAvailableBytesPerSecOverride;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.GetEffectiveAvailableBandwidth
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TotalAvailableBytesPerSecOverride                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBandwidthCheckerLibrary::GetEffectiveAvailableBandwidth(class UObject* WorldContextObject, float TotalAvailableBytesPerSecOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "GetEffectiveAvailableBandwidth");

	Params::BandwidthCheckerLibrary_GetEffectiveAvailableBandwidth Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TotalAvailableBytesPerSecOverride = TotalAvailableBytesPerSecOverride;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.GetEstimatedAdditionalPlayerCapacity
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TotalAvailableBytesPerSecOverride                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UBandwidthCheckerLibrary::GetEstimatedAdditionalPlayerCapacity(class UObject* WorldContextObject, float TotalAvailableBytesPerSecOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "GetEstimatedAdditionalPlayerCapacity");

	Params::BandwidthCheckerLibrary_GetEstimatedAdditionalPlayerCapacity Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TotalAvailableBytesPerSecOverride = TotalAvailableBytesPerSecOverride;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.GetMeasuredAvailableBandwidth
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBandwidthCheckerLibrary::GetMeasuredAvailableBandwidth()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "GetMeasuredAvailableBandwidth");

	Params::BandwidthCheckerLibrary_GetMeasuredAvailableBandwidth Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.QueryNicLinkSpeedBytesPerSec
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InterfaceFriendlyName                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBandwidthCheckerLibrary::QueryNicLinkSpeedBytesPerSec(const class FString& InterfaceFriendlyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "QueryNicLinkSpeedBytesPerSec");

	Params::BandwidthCheckerLibrary_QueryNicLinkSpeedBytesPerSec Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.BandwidthCheckerLibrary.SetMeasuredAvailableBandwidth
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   BytesPerSec                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBandwidthCheckerLibrary::SetMeasuredAvailableBandwidth(float BytesPerSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthCheckerLibrary", "SetMeasuredAvailableBandwidth");

	Params::BandwidthCheckerLibrary_SetMeasuredAvailableBandwidth Parms{};

	Parms.BytesPerSec = BytesPerSec;

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

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

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.BandwidthProbeActor.Client_ReceiveProbeChunk
// (Net, Native, Event, Public, NetClient)
// Parameters:
// const TArray<uint8>&                    Payload                                                (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void ABandwidthProbeActor::Client_ReceiveProbeChunk(const TArray<uint8>& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BandwidthProbeActor", "Client_ReceiveProbeChunk");

	Params::BandwidthProbeActor_Client_ReceiveProbeChunk Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.BandwidthProbeAsyncAction.StartBandwidthProbe
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DurationSeconds                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ChunkBytes                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ChunksPerTickPerClient                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBandwidthProbeAsyncAction*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBandwidthProbeAsyncAction* UBandwidthProbeAsyncAction::StartBandwidthProbe(class UObject* WorldContextObject, float DurationSeconds, int32 ChunkBytes, int32 ChunksPerTickPerClient)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BandwidthProbeAsyncAction", "StartBandwidthProbe");

	Params::BandwidthProbeAsyncAction_StartBandwidthProbe Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.DurationSeconds = DurationSeconds;
	Parms.ChunkBytes = ChunkBytes;
	Parms.ChunksPerTickPerClient = ChunksPerTickPerClient;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.CheckChangeInfos
// (Final, Native, Public, BlueprintCallable)

void UCPP_AC_CustomPhysicsForce::CheckChangeInfos()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "CheckChangeInfos");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.GetRidingAllPawns
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSet<class UPrimitiveComponent*>*       ComputedPrimitives                                     (Parm, OutParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UCPP_AC_CustomPhysicsForce::GetRidingAllPawns(TSet<class UPrimitiveComponent*>* ComputedPrimitives)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "GetRidingAllPawns");

	Params::CPP_AC_CustomPhysicsForce_GetRidingAllPawns Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.GetTotalWeight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCPP_AC_CustomPhysicsForce::GetTotalWeight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "GetTotalWeight");

	Params::CPP_AC_CustomPhysicsForce_GetTotalWeight Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.OnComponentHit
// (Final, Native, Public, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UCPP_AC_CustomPhysicsForce::OnComponentHit(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComponent, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "OnComponentHit");

	Params::CPP_AC_CustomPhysicsForce_OnComponentHit Parms{};

	Parms.HitComponent = HitComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComponent = OtherComponent;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.OnComponentSleep
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              SleepingComponent                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCPP_AC_CustomPhysicsForce::OnComponentSleep(class UPrimitiveComponent* SleepingComponent, class FName BoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "OnComponentSleep");

	Params::CPP_AC_CustomPhysicsForce_OnComponentSleep Parms{};

	Parms.SleepingComponent = SleepingComponent;
	Parms.BoneName = BoneName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.OnComponentWake
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              WakingComponent                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCPP_AC_CustomPhysicsForce::OnComponentWake(class UPrimitiveComponent* WakingComponent, class FName BoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "OnComponentWake");

	Params::CPP_AC_CustomPhysicsForce_OnComponentWake Parms{};

	Parms.WakingComponent = WakingComponent;
	Parms.BoneName = BoneName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.PostPhysicsTickComponent
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCPP_AC_CustomPhysicsForce::PostPhysicsTickComponent(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "PostPhysicsTickComponent");

	Params::CPP_AC_CustomPhysicsForce_PostPhysicsTickComponent Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.ResetHitPointDatas
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// TMap<class UPrimitiveComponent*, struct FVector>ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TMap<class UPrimitiveComponent*, struct FVector> UCPP_AC_CustomPhysicsForce::ResetHitPointDatas()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "ResetHitPointDatas");

	Params::CPP_AC_CustomPhysicsForce_ResetHitPointDatas Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.SweepCheck
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UCPP_AC_CustomPhysicsForce::SweepCheck()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "SweepCheck");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_AC_CustomPhysicsForce.WakeComponent
// (Final, Native, Public)

void UCPP_AC_CustomPhysicsForce::WakeComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_AC_CustomPhysicsForce", "WakeComponent");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_FunctionLibrary.CPP_UpdateLine
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  OutSignalDevices                                       (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UNiagaraSystem*                   NiagaraTemplate                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UNiagaraComponent*>*       SpawnedNiagaraComponents                               (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UCPP_FunctionLibrary::CPP_UpdateLine(class UObject* WorldContextObject, TArray<class AActor*>* OutSignalDevices, class UNiagaraSystem* NiagaraTemplate, TArray<class UNiagaraComponent*>* SpawnedNiagaraComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CPP_FunctionLibrary", "CPP_UpdateLine");

	Params::CPP_FunctionLibrary_CPP_UpdateLine Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.NiagaraTemplate = NiagaraTemplate;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function PenguinHotel.CPP_Glue.AddCustomRevicePower
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   PowerAmount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_Glue::AddCustomRevicePower(float PowerAmount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "AddCustomRevicePower");

	Params::CPP_Glue_AddCustomRevicePower Parms{};

	Parms.PowerAmount = PowerAmount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_Glue.DestroyGlue
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ACPP_Glue::DestroyGlue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "DestroyGlue");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_Glue.Initialize
// (Final, Native, Public, BlueprintCallable)

void ACPP_Glue::Initialize()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "Initialize");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_Glue.InitializeHard
// (Final, Native, Public, BlueprintCallable)

void ACPP_Glue::InitializeHard()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "InitializeHard");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_Glue.IsOverLimitPower
// (Final, Native, Public)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ACPP_Glue::IsOverLimitPower()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "IsOverLimitPower");

	Params::CPP_Glue_IsOverLimitPower Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_Glue.OnRep_RecivedPower
// (Final, Native, Public)
// Parameters:
// float                                   OldHealth                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_Glue::OnRep_RecivedPower(float OldHealth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "OnRep_RecivedPower");

	Params::CPP_Glue_OnRep_RecivedPower Parms{};

	Parms.OldHealth = OldHealth;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_Glue.SetConstantPower
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   power                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_Glue::SetConstantPower(const struct FVector& power)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "SetConstantPower");

	Params::CPP_Glue_SetConstantPower Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_Glue.UpdateGlueVisual
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ACPP_Glue::UpdateGlueVisual()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_Glue", "UpdateGlueVisual");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.AddConstanceForce
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              BeforePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<float>*                          SumForces                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>*     TargetPrimitives                                       (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::AddConstanceForce(class UPrimitiveComponent* TargetPrimitive, class UPrimitiveComponent* BeforePrimitive, TArray<float>* SumForces, TArray<class UPrimitiveComponent*>* TargetPrimitives)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddConstanceForce");

	Params::CPP_LinkDataBank_AddConstanceForce Parms{};

	Parms.TargetPrimitive = TargetPrimitive;
	Parms.BeforePrimitive = BeforePrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function PenguinHotel.CPP_LinkDataBank.AddConstanceForceDefault
// (Final, Native, Public)

void ACPP_LinkDataBank::AddConstanceForceDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddConstanceForceDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.AddConstanceForceDefaultV2
// (Final, Native, Public)

void ACPP_LinkDataBank::AddConstanceForceDefaultV2()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddConstanceForceDefaultV2");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.AddConstanceForceToGlue
// (Final, Native, Public)
// Parameters:
// const TArray<float>&                    SumForces                                              (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<class UPrimitiveComponent*>&TargetPrimitives                                       (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   AttenuationValue                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::AddConstanceForceToGlue(const TArray<float>& SumForces, const TArray<class UPrimitiveComponent*>& TargetPrimitives, float AttenuationValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddConstanceForceToGlue");

	Params::CPP_LinkDataBank_AddConstanceForceToGlue Parms{};

	Parms.SumForces = std::move(SumForces);
	Parms.TargetPrimitives = std::move(TargetPrimitives);
	Parms.AttenuationValue = AttenuationValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.AddConstanceForceV2
// (Final, Native, Public)
// Parameters:
// const struct FCPP_OrderInfo&            OrderInfo                                              (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              StaticPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ACPP_LinkDataBank::AddConstanceForceV2(const struct FCPP_OrderInfo& OrderInfo, class UPrimitiveComponent* StaticPrimitive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddConstanceForceV2");

	Params::CPP_LinkDataBank_AddConstanceForceV2 Parms{};

	Parms.OrderInfo = std::move(OrderInfo);
	Parms.StaticPrimitive = StaticPrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.AddConstanceForceV3
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              RootStaticComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCPP_OrderInfo&            OrderInfo                                              (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   CurrentIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSet<int32>*                            ComputedIndexs                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ACPP_LinkDataBank::AddConstanceForceV3(class UPrimitiveComponent* RootStaticComponent, const struct FCPP_OrderInfo& OrderInfo, int32 CurrentIndex, TSet<int32>* ComputedIndexs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddConstanceForceV3");

	Params::CPP_LinkDataBank_AddConstanceForceV3 Parms{};

	Parms.RootStaticComponent = RootStaticComponent;
	Parms.OrderInfo = std::move(OrderInfo);
	Parms.CurrentIndex = CurrentIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.AddForceGlues
// (Final, Native, Public)
// Parameters:
// const TArray<class ACPP_Glue*>&         Glues                                                  (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// float                                   PowerValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::AddForceGlues(const TArray<class ACPP_Glue*>& Glues, float PowerValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddForceGlues");

	Params::CPP_LinkDataBank_AddForceGlues Parms{};

	Parms.Glues = std::move(Glues);
	Parms.PowerValue = PowerValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.AddGlueRef
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              PrimitiveComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACPP_Glue*                        Glue                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::AddGlueRef(class UPrimitiveComponent* PrimitiveComponent, class ACPP_Glue* Glue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddGlueRef");

	Params::CPP_LinkDataBank_AddGlueRef Parms{};

	Parms.PrimitiveComponent = PrimitiveComponent;
	Parms.Glue = Glue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.AddWaveData
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              SourcePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ForceValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::AddWaveData(class UPrimitiveComponent* SourcePrimitive, class UPrimitiveComponent* TargetPrimitive, float ForceValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "AddWaveData");

	Params::CPP_LinkDataBank_AddWaveData Parms{};

	Parms.SourcePrimitive = SourcePrimitive;
	Parms.TargetPrimitive = TargetPrimitive;
	Parms.ForceValue = ForceValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.GetAdjacentPrimitives
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        PrimitiveComponent                                     (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSet<class UPrimitiveComponent*>& Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UPrimitiveComponent*> ACPP_LinkDataBank::GetAdjacentPrimitives(const class UPrimitiveComponent* PrimitiveComponent, const TSet<class UPrimitiveComponent*>& Filter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "GetAdjacentPrimitives");

	Params::CPP_LinkDataBank_GetAdjacentPrimitives Parms{};

	Parms.PrimitiveComponent = PrimitiveComponent;
	Parms.Filter = std::move(Filter);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.GetGroupInfo
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              ParentPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FCPP_GlueRefInfo                 ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FCPP_GlueRefInfo ACPP_LinkDataBank::GetGroupInfo(class UPrimitiveComponent* ParentPrimitive, class UPrimitiveComponent* TargetPrimitive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "GetGroupInfo");

	Params::CPP_LinkDataBank_GetGroupInfo Parms{};

	Parms.ParentPrimitive = ParentPrimitive;
	Parms.TargetPrimitive = TargetPrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.GetLinkedLength
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              ParentPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ACPP_LinkDataBank::GetLinkedLength(class UPrimitiveComponent* ParentPrimitive, class UPrimitiveComponent* TargetPrimitive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "GetLinkedLength");

	Params::CPP_LinkDataBank_GetLinkedLength Parms{};

	Parms.ParentPrimitive = ParentPrimitive;
	Parms.TargetPrimitive = TargetPrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.GetLinkedMergePrimitve
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              ParentPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent**             Variable                                               (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::GetLinkedMergePrimitve(class UPrimitiveComponent* ParentPrimitive, class UPrimitiveComponent* TargetPrimitive, class UPrimitiveComponent** Variable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "GetLinkedMergePrimitve");

	Params::CPP_LinkDataBank_GetLinkedMergePrimitve Parms{};

	Parms.ParentPrimitive = ParentPrimitive;
	Parms.TargetPrimitive = TargetPrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function PenguinHotel.CPP_LinkDataBank.GetNormalizedWeight
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              SourcePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSet<class UPrimitiveComponent*>& IgnorePrimitives                                       (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TMap<class UPrimitiveComponent*, float> ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TMap<class UPrimitiveComponent*, float> ACPP_LinkDataBank::GetNormalizedWeight(class UPrimitiveComponent* SourcePrimitive, const TSet<class UPrimitiveComponent*>& IgnorePrimitives)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "GetNormalizedWeight");

	Params::CPP_LinkDataBank_GetNormalizedWeight Parms{};

	Parms.SourcePrimitive = SourcePrimitive;
	Parms.IgnorePrimitives = std::move(IgnorePrimitives);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.IsBreakCheck
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class ACPP_Glue*>&         Glues                                                  (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// float                                   AddPower                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ACPP_LinkDataBank::IsBreakCheck(const TArray<class ACPP_Glue*>& Glues, float AddPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "IsBreakCheck");

	Params::CPP_LinkDataBank_IsBreakCheck Parms{};

	Parms.Glues = std::move(Glues);
	Parms.AddPower = AddPower;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.RemoveGlueRef
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ACPP_Glue*                        Glue                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UPrimitiveComponent*> ACPP_LinkDataBank::RemoveGlueRef(class ACPP_Glue* Glue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "RemoveGlueRef");

	Params::CPP_LinkDataBank_RemoveGlueRef Parms{};

	Parms.Glue = Glue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.ResetAllGlueRecivedPower
// (Final, Native, Public)

void ACPP_LinkDataBank::ResetAllGlueRecivedPower()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "ResetAllGlueRecivedPower");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.Sepqration
// (Final, Native, Public)

void ACPP_LinkDataBank::Sepqration()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "Sepqration");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.SepqrationCheck
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              Primitive                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::SepqrationCheck(class UPrimitiveComponent* Primitive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SepqrationCheck");

	Params::CPP_LinkDataBank_SepqrationCheck Parms{};

	Parms.Primitive = Primitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.SetBranchOrder
// (Final, Native, Public, BlueprintCallable)

void ACPP_LinkDataBank::SetBranchOrder()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetBranchOrder");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.SetBranchWeights
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSet<class UPrimitiveComponent*>*       ProcessedPrimitives                                    (Parm, OutParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              BeforePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  WeightValue                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>*     MergePointPrimitivesParam                              (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>*     SelfPointPrimitives                                    (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::SetBranchWeights(TSet<class UPrimitiveComponent*>* ProcessedPrimitives, class UPrimitiveComponent* TargetPrimitive, class UPrimitiveComponent* BeforePrimitive, float* WeightValue, TArray<class UPrimitiveComponent*>* MergePointPrimitivesParam, TArray<class UPrimitiveComponent*>* SelfPointPrimitives)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetBranchWeights");

	Params::CPP_LinkDataBank_SetBranchWeights Parms{};

	Parms.TargetPrimitive = TargetPrimitive;
	Parms.BeforePrimitive = BeforePrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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

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


// Function PenguinHotel.CPP_LinkDataBank.SetBranchWeightsDefault
// (Final, Native, Public, BlueprintCallable)

void ACPP_LinkDataBank::SetBranchWeightsDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetBranchWeightsDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.SetBranchWeightsDefaultV2
// (Final, Native, Public, BlueprintCallable)

void ACPP_LinkDataBank::SetBranchWeightsDefaultV2()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetBranchWeightsDefaultV2");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.SetBranchWeightsV2
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSet<class UPrimitiveComponent*>*       ProcessedPrimitives                                    (Parm, OutParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              ParentRootPrimitive                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  WeightValue                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent**             LastPrimitive                                          (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::SetBranchWeightsV2(TSet<class UPrimitiveComponent*>* ProcessedPrimitives, class UPrimitiveComponent* TargetPrimitive, class UPrimitiveComponent* ParentRootPrimitive, float* WeightValue, class UPrimitiveComponent** LastPrimitive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetBranchWeightsV2");

	Params::CPP_LinkDataBank_SetBranchWeightsV2 Parms{};

	Parms.TargetPrimitive = TargetPrimitive;
	Parms.ParentRootPrimitive = ParentRootPrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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


// Function PenguinHotel.CPP_LinkDataBank.SetLinkedLength
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              ParentPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::SetLinkedLength(class UPrimitiveComponent* ParentPrimitive, class UPrimitiveComponent* TargetPrimitive, float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetLinkedLength");

	Params::CPP_LinkDataBank_SetLinkedLength Parms{};

	Parms.ParentPrimitive = ParentPrimitive;
	Parms.TargetPrimitive = TargetPrimitive;
	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.SetLinkedMergePrimitve
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              ParentPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              SetPrimitive                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::SetLinkedMergePrimitve(class UPrimitiveComponent* ParentPrimitive, class UPrimitiveComponent* TargetPrimitive, class UPrimitiveComponent* SetPrimitive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetLinkedMergePrimitve");

	Params::CPP_LinkDataBank_SetLinkedMergePrimitve Parms{};

	Parms.ParentPrimitive = ParentPrimitive;
	Parms.TargetPrimitive = TargetPrimitive;
	Parms.SetPrimitive = SetPrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.SetupCurrentForceWave
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ForceValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::SetupCurrentForceWave(class UPrimitiveComponent* TargetPrimitive, float ForceValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "SetupCurrentForceWave");

	Params::CPP_LinkDataBank_SetupCurrentForceWave Parms{};

	Parms.TargetPrimitive = TargetPrimitive;
	Parms.ForceValue = ForceValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.TransmissionPower
// (Final, Native, Public, HasOutParams)
// Parameters:
// TSet<class UPrimitiveComponent*>*       ProcessedPrimitives                                    (Parm, OutParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              SourcePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              BeforePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   power                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::TransmissionPower(TSet<class UPrimitiveComponent*>* ProcessedPrimitives, class UPrimitiveComponent* SourcePrimitive, class UPrimitiveComponent* BeforePrimitive, float power)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "TransmissionPower");

	Params::CPP_LinkDataBank_TransmissionPower Parms{};

	Parms.SourcePrimitive = SourcePrimitive;
	Parms.BeforePrimitive = BeforePrimitive;
	Parms.power = power;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function PenguinHotel.CPP_LinkDataBank.TransmissionPowerDefault
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              SourcePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   power                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::TransmissionPowerDefault(class UPrimitiveComponent* SourcePrimitive, float power)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "TransmissionPowerDefault");

	Params::CPP_LinkDataBank_TransmissionPowerDefault Parms{};

	Parms.SourcePrimitive = SourcePrimitive;
	Parms.power = power;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.TransmissionPowerSingle
// (Final, Native, Public)
// Parameters:
// const struct FCPP_OrderInfo&            OrderInfo                                              (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<struct FCPP_CurrentForceWave>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<struct FCPP_CurrentForceWave> ACPP_LinkDataBank::TransmissionPowerSingle(const struct FCPP_OrderInfo& OrderInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "TransmissionPowerSingle");

	Params::CPP_LinkDataBank_TransmissionPowerSingle Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_LinkDataBank.TransmissionStaticPower
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              TraceTarget                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BeforeWeight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCPP_OrderInfo&            OrderInfo                                              (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::TransmissionStaticPower(class UPrimitiveComponent* TraceTarget, float BeforeWeight, const struct FCPP_OrderInfo& OrderInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "TransmissionStaticPower");

	Params::CPP_LinkDataBank_TransmissionStaticPower Parms{};

	Parms.TraceTarget = TraceTarget;
	Parms.BeforeWeight = BeforeWeight;
	Parms.OrderInfo = std::move(OrderInfo);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.TransmissionStaticPowerDefault
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   WeightValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::TransmissionStaticPowerDefault(class UPrimitiveComponent* TargetPrimitive, float WeightValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "TransmissionStaticPowerDefault");

	Params::CPP_LinkDataBank_TransmissionStaticPowerDefault Parms{};

	Parms.TargetPrimitive = TargetPrimitive;
	Parms.WeightValue = WeightValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.UpdateBranchWeightSum
// (Final, Native, Public, HasOutParams)
// Parameters:
// TArray<class UPrimitiveComponent*>*     ProcessedMergePoints                                   (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*>*     ProcessedLoopPoints                                    (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              BeforePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  SumValue                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::UpdateBranchWeightSum(TArray<class UPrimitiveComponent*>* ProcessedMergePoints, TArray<class UPrimitiveComponent*>* ProcessedLoopPoints, class UPrimitiveComponent* TargetPrimitive, class UPrimitiveComponent* BeforePrimitive, float* SumValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateBranchWeightSum");

	Params::CPP_LinkDataBank_UpdateBranchWeightSum Parms{};

	Parms.TargetPrimitive = TargetPrimitive;
	Parms.BeforePrimitive = BeforePrimitive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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


// Function PenguinHotel.CPP_LinkDataBank.UpdateBranchWeightSumDefault
// (Final, Native, Public)

void ACPP_LinkDataBank::UpdateBranchWeightSumDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateBranchWeightSumDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.UpdateEndPointPrimitives
// (Final, Native, Public, BlueprintCallable)

void ACPP_LinkDataBank::UpdateEndPointPrimitives()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateEndPointPrimitives");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.UpdateMergePointPrimitives
// (Final, Native, Public)

void ACPP_LinkDataBank::UpdateMergePointPrimitives()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateMergePointPrimitives");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.UpdateStaticWeights
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              TargetPrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              BeforePrimitive                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BeforeValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::UpdateStaticWeights(class UPrimitiveComponent* TargetPrimitive, class UPrimitiveComponent* BeforePrimitive, float BeforeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateStaticWeights");

	Params::CPP_LinkDataBank_UpdateStaticWeights Parms{};

	Parms.TargetPrimitive = TargetPrimitive;
	Parms.BeforePrimitive = BeforePrimitive;
	Parms.BeforeValue = BeforeValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.UpdateStaticWeightsDefault
// (Final, Native, Public)

void ACPP_LinkDataBank::UpdateStaticWeightsDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateStaticWeightsDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.UpdateStaticWeightsDefaultV2
// (Final, Native, Public)

void ACPP_LinkDataBank::UpdateStaticWeightsDefaultV2()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateStaticWeightsDefaultV2");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkDataBank.UpdateStaticWeightsV2
// (Final, Native, Public, HasOutParams)
// Parameters:
// TArray<struct FCPP_OrderInfo>*          CurrentState                                           (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FCPP_OrderInfo&            OrderInfo                                              (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              SourceStatic                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_LinkDataBank::UpdateStaticWeightsV2(TArray<struct FCPP_OrderInfo>* CurrentState, const struct FCPP_OrderInfo& OrderInfo, class UPrimitiveComponent* SourceStatic)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkDataBank", "UpdateStaticWeightsV2");

	Params::CPP_LinkDataBank_UpdateStaticWeightsV2 Parms{};

	Parms.OrderInfo = std::move(OrderInfo);
	Parms.SourceStatic = SourceStatic;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function PenguinHotel.CPP_LinkManager.PhysicsForceUpdate
// (Final, Native, Public)

void ACPP_LinkManager::PhysicsForceUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkManager", "PhysicsForceUpdate");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkManager.ReplicateGlueVisualDatas
// (Net, Native, Event, NetMulticast, Public)
// Parameters:
// const TArray<class ACPP_Glue*>&         GlueVisualDatasKey                                     (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<float>&                    GlueVisualDatasValue                                   (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void ACPP_LinkManager::ReplicateGlueVisualDatas(const TArray<class ACPP_Glue*>& GlueVisualDatasKey, const TArray<float>& GlueVisualDatasValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkManager", "ReplicateGlueVisualDatas");

	Params::CPP_LinkManager_ReplicateGlueVisualDatas Parms{};

	Parms.GlueVisualDatasKey = std::move(GlueVisualDatasKey);
	Parms.GlueVisualDatasValue = std::move(GlueVisualDatasValue);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_LinkManager.UpdateForceWave
// (Final, Native, Public)

void ACPP_LinkManager::UpdateForceWave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_LinkManager", "UpdateForceWave");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_pChainManager.AddRevivalCheck
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   KeyNumber                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_pChainManager::AddRevivalCheck(int32 KeyNumber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_pChainManager", "AddRevivalCheck");

	Params::CPP_pChainManager_AddRevivalCheck Parms{};

	Parms.KeyNumber = KeyNumber;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_pChainManager.DamagePlanet
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UInstancedStaticMeshComponent*    InstancedMeshComponent                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InstanceIndex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlanetDamageInfo&         DamageInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// struct FPlanetDamageRezult              ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPlanetDamageRezult ACPP_pChainManager::DamagePlanet(class UInstancedStaticMeshComponent* InstancedMeshComponent, int32 InstanceIndex, const struct FPlanetDamageInfo& DamageInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_pChainManager", "DamagePlanet");

	Params::CPP_pChainManager_DamagePlanet Parms{};

	Parms.InstancedMeshComponent = InstancedMeshComponent;
	Parms.InstanceIndex = InstanceIndex;
	Parms.DamageInfo = std::move(DamageInfo);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_pChainManager.GetRegisterComponentDatas
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   KeyNumber                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPlanetSearchRezult              ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FPlanetSearchRezult ACPP_pChainManager::GetRegisterComponentDatas(int32 KeyNumber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_pChainManager", "GetRegisterComponentDatas");

	Params::CPP_pChainManager_GetRegisterComponentDatas Parms{};

	Parms.KeyNumber = KeyNumber;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CPP_pChainManager.RegisterPlanetDatas
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   KeyNumber                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInstancedStaticMeshComponent*    InstancedMeshComponent                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlanetInfo&               DefaultData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)

void ACPP_pChainManager::RegisterPlanetDatas(int32 KeyNumber, class UInstancedStaticMeshComponent* InstancedMeshComponent, const struct FPlanetInfo& DefaultData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_pChainManager", "RegisterPlanetDatas");

	Params::CPP_pChainManager_RegisterPlanetDatas Parms{};

	Parms.KeyNumber = KeyNumber;
	Parms.InstancedMeshComponent = InstancedMeshComponent;
	Parms.DefaultData = std::move(DefaultData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_pChainManager.RevivalCheck
// (Final, Native, Public)

void ACPP_pChainManager::RevivalCheck()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_pChainManager", "RevivalCheck");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CPP_pChainManager.RevivalPlanet
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   KeyNumber                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACPP_pChainManager::RevivalPlanet(int32 KeyNumber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CPP_pChainManager", "RevivalPlanet");

	Params::CPP_pChainManager_RevivalPlanet Parms{};

	Parms.KeyNumber = KeyNumber;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CustomAIController.GetHeadLocRot
// (Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        OutRotation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ACustomAIController::GetHeadLocRot(struct FVector* OutLocation, struct FRotator* OutRotation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomAIController", "GetHeadLocRot");

	Params::CustomAIController_GetHeadLocRot Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function PenguinHotel.CustomProgramFunctionLibrary.ApplyTorqueForce
// (Final, Native, Static, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  RotationA                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  RotationB                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAccelChange                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCustomProgramFunctionLibrary::ApplyTorqueForce(class UPrimitiveComponent* Component, const struct FRotator& RotationA, const struct FRotator& RotationB, float Strength, bool bAccelChange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "ApplyTorqueForce");

	Params::CustomProgramFunctionLibrary_ApplyTorqueForce Parms{};

	Parms.Component = Component;
	Parms.RotationA = std::move(RotationA);
	Parms.RotationB = std::move(RotationB);
	Parms.Strength = Strength;
	Parms.bAccelChange = bAccelChange;

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

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

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.CustomProgramFunctionLibrary.CalculateTorqueForRotation
// (Final, Native, Static, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  RotationA                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  RotationB                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UCustomProgramFunctionLibrary::CalculateTorqueForRotation(const struct FRotator& RotationA, const struct FRotator& RotationB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "CalculateTorqueForRotation");

	Params::CustomProgramFunctionLibrary_CalculateTorqueForRotation Parms{};

	Parms.RotationA = std::move(RotationA);
	Parms.RotationB = std::move(RotationB);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CustomProgramFunctionLibrary.FilterActorsByInterface
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class AActor*>&            Actors                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TSubclassOf<class IInterface>           Interface                                              (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  OutActors                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UCustomProgramFunctionLibrary::FilterActorsByInterface(const TArray<class AActor*>& Actors, TSubclassOf<class IInterface> Interface, TArray<class AActor*>* OutActors)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "FilterActorsByInterface");

	Params::CustomProgramFunctionLibrary_FilterActorsByInterface Parms{};

	Parms.Actors = std::move(Actors);
	Parms.Interface = Interface;

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

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

	Func->FunctionFlags = Flgs;

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


// Function PenguinHotel.CustomProgramFunctionLibrary.GetActiveVoiceInputDevice
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UCustomProgramFunctionLibrary::GetActiveVoiceInputDevice()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "GetActiveVoiceInputDevice");

	Params::CustomProgramFunctionLibrary_GetActiveVoiceInputDevice Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CustomProgramFunctionLibrary.GetNearestActor
// (Final, Native, Static, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            Actors                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// float*                                  OutDistance                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UCustomProgramFunctionLibrary::GetNearestActor(const struct FVector& Location, const TArray<class AActor*>& Actors, float* OutDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "GetNearestActor");

	Params::CustomProgramFunctionLibrary_GetNearestActor Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.CustomProgramFunctionLibrary.GetNearestActorByDotProduct
// (Final, Native, Static, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            Actors                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// float*                                  OutDotProduct                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UCustomProgramFunctionLibrary::GetNearestActorByDotProduct(const struct FVector& Location, const struct FVector& Direction, const TArray<class AActor*>& Actors, float* OutDotProduct)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "GetNearestActorByDotProduct");

	Params::CustomProgramFunctionLibrary_GetNearestActorByDotProduct Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.CustomProgramFunctionLibrary.GetPawnRemoteViewPitch
// (Final, Native, Static, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCustomProgramFunctionLibrary::GetPawnRemoteViewPitch(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "GetPawnRemoteViewPitch");

	Params::CustomProgramFunctionLibrary_GetPawnRemoteViewPitch Parms{};

	Parms.Pawn = Pawn;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.CustomProgramFunctionLibrary.GetRootMotionDelta
// (Final, Native, Static, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           SkeletalMeshComp                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      OutDeltaTransform                                      (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCustomProgramFunctionLibrary::GetRootMotionDelta(class USkeletalMeshComponent* SkeletalMeshComp, struct FTransform* OutDeltaTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "GetRootMotionDelta");

	Params::CustomProgramFunctionLibrary_GetRootMotionDelta Parms{};

	Parms.SkeletalMeshComp = SkeletalMeshComp;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.CustomProgramFunctionLibrary.GetTrappedText
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    Source                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ID                                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          Value                                                  (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutSource                                              (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCustomProgramFunctionLibrary::GetTrappedText(const class FString& Source, const class FString& ID, class FString* Value, class FString* OutSource)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "GetTrappedText");

	Params::CustomProgramFunctionLibrary_GetTrappedText Parms{};

	Parms.Source = std::move(Source);
	Parms.ID = std::move(ID);

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function PenguinHotel.CustomProgramFunctionLibrary.HashStringMD5
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// const class FString&                    Source                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UCustomProgramFunctionLibrary::HashStringMD5(const class FString& Source)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CustomProgramFunctionLibrary", "HashStringMD5");

	Params::CustomProgramFunctionLibrary_HashStringMD5 Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.ClearDynamicCapsuleDesiredHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IDynamicCapsuleHeightControlInterface::ClearDynamicCapsuleDesiredHalfHeight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "ClearDynamicCapsuleDesiredHalfHeight");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.SetDynamicCapsuleCrouching
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bNewCrouching                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IDynamicCapsuleHeightControlInterface::SetDynamicCapsuleCrouching(bool bNewCrouching)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "SetDynamicCapsuleCrouching");

	Params::DynamicCapsuleHeightControlInterface_SetDynamicCapsuleCrouching Parms{};

	Parms.bNewCrouching = bNewCrouching;

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

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

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.SetDynamicCapsuleCrouchingHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   NewHalfHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IDynamicCapsuleHeightControlInterface::SetDynamicCapsuleCrouchingHalfHeight(float NewHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "SetDynamicCapsuleCrouchingHalfHeight");

	Params::DynamicCapsuleHeightControlInterface_SetDynamicCapsuleCrouchingHalfHeight Parms{};

	Parms.NewHalfHeight = NewHalfHeight;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.SetDynamicCapsuleDesiredHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   NewHalfHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IDynamicCapsuleHeightControlInterface::SetDynamicCapsuleDesiredHalfHeight(float NewHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "SetDynamicCapsuleDesiredHalfHeight");

	Params::DynamicCapsuleHeightControlInterface_SetDynamicCapsuleDesiredHalfHeight Parms{};

	Parms.NewHalfHeight = NewHalfHeight;

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

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

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.SetDynamicCapsuleStandingHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   NewHalfHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IDynamicCapsuleHeightControlInterface::SetDynamicCapsuleStandingHalfHeight(float NewHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "SetDynamicCapsuleStandingHalfHeight");

	Params::DynamicCapsuleHeightControlInterface_SetDynamicCapsuleStandingHalfHeight Parms{};

	Parms.NewHalfHeight = NewHalfHeight;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.GetDynamicCapsuleCrouchingHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IDynamicCapsuleHeightControlInterface::GetDynamicCapsuleCrouchingHalfHeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "GetDynamicCapsuleCrouchingHalfHeight");

	Params::DynamicCapsuleHeightControlInterface_GetDynamicCapsuleCrouchingHalfHeight Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.GetDynamicCapsuleCurrentHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IDynamicCapsuleHeightControlInterface::GetDynamicCapsuleCurrentHalfHeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "GetDynamicCapsuleCurrentHalfHeight");

	Params::DynamicCapsuleHeightControlInterface_GetDynamicCapsuleCurrentHalfHeight Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.GetDynamicCapsuleDesiredHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IDynamicCapsuleHeightControlInterface::GetDynamicCapsuleDesiredHalfHeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "GetDynamicCapsuleDesiredHalfHeight");

	Params::DynamicCapsuleHeightControlInterface_GetDynamicCapsuleDesiredHalfHeight Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.GetDynamicCapsuleStandingHalfHeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IDynamicCapsuleHeightControlInterface::GetDynamicCapsuleStandingHalfHeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "GetDynamicCapsuleStandingHalfHeight");

	Params::DynamicCapsuleHeightControlInterface_GetDynamicCapsuleStandingHalfHeight Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.IsDynamicCapsuleCrouching
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IDynamicCapsuleHeightControlInterface::IsDynamicCapsuleCrouching() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "IsDynamicCapsuleCrouching");

	Params::DynamicCapsuleHeightControlInterface_IsDynamicCapsuleCrouching Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsuleHeightControlInterface.WriteDynamicCapsuleInput
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FMoverInputCmdContext&           InputCmd                                               (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void IDynamicCapsuleHeightControlInterface::WriteDynamicCapsuleInput(struct FMoverInputCmdContext& InputCmd) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DynamicCapsuleHeightControlInterface", "WriteDynamicCapsuleInput");

	Params::DynamicCapsuleHeightControlInterface_WriteDynamicCapsuleInput Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	InputCmd = std::move(Parms.InputCmd);
}


// Function PenguinHotel.DynamicCapsuleHeightControlComponent.OnMoverPostSimulationTick
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UDynamicCapsuleHeightControlComponent::OnMoverPostSimulationTick(const struct FMoverTimeStep& TimeStep)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsuleHeightControlComponent", "OnMoverPostSimulationTick");

	Params::DynamicCapsuleHeightControlComponent_OnMoverPostSimulationTick Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsuleHeightControlComponent.GetMoverComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMoverComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMoverComponent* UDynamicCapsuleHeightControlComponent::GetMoverComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsuleHeightControlComponent", "GetMoverComponent");

	Params::DynamicCapsuleHeightControlComponent_GetMoverComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenWalkingMode.ClearDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)

void UDynamicCapsulePhysicsDrivenWalkingMode::ClearDesiredCapsuleHalfHeight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsulePhysicsDrivenWalkingMode", "ClearDesiredCapsuleHalfHeight");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenWalkingMode.SetDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InHalfHeight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDynamicCapsulePhysicsDrivenWalkingMode::SetDesiredCapsuleHalfHeight(float InHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsulePhysicsDrivenWalkingMode", "SetDesiredCapsuleHalfHeight");

	Params::DynamicCapsulePhysicsDrivenWalkingMode_SetDesiredCapsuleHalfHeight Parms{};

	Parms.InHalfHeight = InHalfHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenFlyingMode.ClearDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)

void UDynamicCapsulePhysicsDrivenFlyingMode::ClearDesiredCapsuleHalfHeight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsulePhysicsDrivenFlyingMode", "ClearDesiredCapsuleHalfHeight");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenFlyingMode.SetDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InHalfHeight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDynamicCapsulePhysicsDrivenFlyingMode::SetDesiredCapsuleHalfHeight(float InHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsulePhysicsDrivenFlyingMode", "SetDesiredCapsuleHalfHeight");

	Params::DynamicCapsulePhysicsDrivenFlyingMode_SetDesiredCapsuleHalfHeight Parms{};

	Parms.InHalfHeight = InHalfHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenFallingMode.ClearDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)

void UDynamicCapsulePhysicsDrivenFallingMode::ClearDesiredCapsuleHalfHeight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsulePhysicsDrivenFallingMode", "ClearDesiredCapsuleHalfHeight");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenFallingMode.SetDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InHalfHeight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDynamicCapsulePhysicsDrivenFallingMode::SetDesiredCapsuleHalfHeight(float InHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DynamicCapsulePhysicsDrivenFallingMode", "SetDesiredCapsuleHalfHeight");

	Params::DynamicCapsulePhysicsDrivenFallingMode_SetDesiredCapsuleHalfHeight Parms{};

	Parms.InHalfHeight = InHalfHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenLibrary.ApplyCapsuleHalfHeightToMover
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UMoverComponent*                  MoverComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NewCapsuleHalfHeight                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckBlockedExpansion                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDynamicCapsulePhysicsDrivenLibrary::ApplyCapsuleHalfHeightToMover(class UMoverComponent* MoverComponent, float NewCapsuleHalfHeight, bool bCheckBlockedExpansion)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("DynamicCapsulePhysicsDrivenLibrary", "ApplyCapsuleHalfHeightToMover");

	Params::DynamicCapsulePhysicsDrivenLibrary_ApplyCapsuleHalfHeightToMover Parms{};

	Parms.MoverComponent = MoverComponent;
	Parms.NewCapsuleHalfHeight = NewCapsuleHalfHeight;
	Parms.bCheckBlockedExpansion = bCheckBlockedExpansion;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.DynamicCapsulePhysicsDrivenLibrary.CanSetCapsuleHalfHeight
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UCapsuleComponent*                CapsuleComponent                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NewCapsuleHalfHeight                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bKeepBottomPosition                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   UpDirection                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDynamicCapsulePhysicsDrivenLibrary::CanSetCapsuleHalfHeight(class UCapsuleComponent* CapsuleComponent, float NewCapsuleHalfHeight, bool bKeepBottomPosition, const struct FVector& UpDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("DynamicCapsulePhysicsDrivenLibrary", "CanSetCapsuleHalfHeight");

	Params::DynamicCapsulePhysicsDrivenLibrary_CanSetCapsuleHalfHeight Parms{};

	Parms.CapsuleComponent = CapsuleComponent;
	Parms.NewCapsuleHalfHeight = NewCapsuleHalfHeight;
	Parms.bKeepBottomPosition = bKeepBottomPosition;
	Parms.UpDirection = std::move(UpDirection);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.EOSPlayerReportAsyncAction.SendEOSPlayerReport
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject_0                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ReporterProductUserId                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ReportedProductUserId                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEOSPlayerReportCategory                Category                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Message                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ContextJson                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEOSPlayerReportAsyncAction*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEOSPlayerReportAsyncAction* UEOSPlayerReportAsyncAction::SendEOSPlayerReport(class UObject* WorldContextObject_0, const class FString& ReporterProductUserId, const class FString& ReportedProductUserId, EEOSPlayerReportCategory Category, const class FString& Message, const class FString& ContextJson)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EOSPlayerReportAsyncAction", "SendEOSPlayerReport");

	Params::EOSPlayerReportAsyncAction_SendEOSPlayerReport Parms{};

	Parms.WorldContextObject_0 = WorldContextObject_0;
	Parms.ReporterProductUserId = std::move(ReporterProductUserId);
	Parms.ReportedProductUserId = std::move(ReportedProductUserId);
	Parms.Category = Category;
	Parms.Message = std::move(Message);
	Parms.ContextJson = std::move(ContextJson);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.GetDefaultLocalModsFolder
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UModBlueprintLibrary::GetDefaultLocalModsFolder()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "GetDefaultLocalModsFolder");

	Params::ModBlueprintLibrary_GetDefaultLocalModsFolder Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.GetLevelsFromAssetRegistryBin
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    AssetRegistryPath                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ModFolderPath                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    TocFilePath                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    RequiredPackagePathPrefix                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    RequiredMapSuffix                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FIoStoreModLevelInfo>*    OutLevels                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UModBlueprintLibrary::GetLevelsFromAssetRegistryBin(const class FString& AssetRegistryPath, const class FString& ModFolderPath, const class FString& TocFilePath, const class FString& RequiredPackagePathPrefix, const class FString& RequiredMapSuffix, TArray<struct FIoStoreModLevelInfo>* OutLevels)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "GetLevelsFromAssetRegistryBin");

	Params::ModBlueprintLibrary_GetLevelsFromAssetRegistryBin Parms{};

	Parms.AssetRegistryPath = std::move(AssetRegistryPath);
	Parms.ModFolderPath = std::move(ModFolderPath);
	Parms.TocFilePath = std::move(TocFilePath);
	Parms.RequiredPackagePathPrefix = std::move(RequiredPackagePathPrefix);
	Parms.RequiredMapSuffix = std::move(RequiredMapSuffix);

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.LoadModLevelInstanceByPath
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    LevelPath                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   bOutSuccess                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULevelStreamingDynamic*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULevelStreamingDynamic* UModBlueprintLibrary::LoadModLevelInstanceByPath(class UObject* WorldContextObject, const class FString& LevelPath, const struct FVector& Location, const struct FRotator& Rotation, bool* bOutSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "LoadModLevelInstanceByPath");

	Params::ModBlueprintLibrary_LoadModLevelInstanceByPath Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelPath = std::move(LevelPath);
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.MountAllIoStoreContainersInFolder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    FolderPath                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UModBlueprintLibrary::MountAllIoStoreContainersInFolder(const class FString& FolderPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "MountAllIoStoreContainersInFolder");

	Params::ModBlueprintLibrary_MountAllIoStoreContainersInFolder Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.MountAllPakFilesInFolder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    FolderPath                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UModBlueprintLibrary::MountAllPakFilesInFolder(const class FString& FolderPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "MountAllPakFilesInFolder");

	Params::ModBlueprintLibrary_MountAllPakFilesInFolder Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.MountIoStoreAndGetLevelsFromAssetRegistry
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ModFolderPath                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AssetRegistryFileName                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    RequiredPackagePathPrefix                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    RequiredMapSuffix                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FIoStoreModLevelInfo>*    OutLevels                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32*                                  OutMountedContainerCount                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UModBlueprintLibrary::MountIoStoreAndGetLevelsFromAssetRegistry(const class FString& ModFolderPath, const class FString& AssetRegistryFileName, const class FString& RequiredPackagePathPrefix, const class FString& RequiredMapSuffix, TArray<struct FIoStoreModLevelInfo>* OutLevels, int32* OutMountedContainerCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "MountIoStoreAndGetLevelsFromAssetRegistry");

	Params::ModBlueprintLibrary_MountIoStoreAndGetLevelsFromAssetRegistry Parms{};

	Parms.ModFolderPath = std::move(ModFolderPath);
	Parms.AssetRegistryFileName = std::move(AssetRegistryFileName);
	Parms.RequiredPackagePathPrefix = std::move(RequiredPackagePathPrefix);
	Parms.RequiredMapSuffix = std::move(RequiredMapSuffix);

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

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

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.MountIoStoreContainer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    TocPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UModBlueprintLibrary::MountIoStoreContainer(const class FString& TocPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "MountIoStoreContainer");

	Params::ModBlueprintLibrary_MountIoStoreContainer Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.MountPakAndLoadLevelFromJson
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ModFolderPath                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    JsonFileName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   bOutSuccess                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FModMapJsonInfo*                 OutInfo                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// class ULevelStreamingDynamic*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULevelStreamingDynamic* UModBlueprintLibrary::MountPakAndLoadLevelFromJson(class UObject* WorldContextObject, const class FString& ModFolderPath, const class FString& JsonFileName, const struct FVector& Location, const struct FRotator& Rotation, bool* bOutSuccess, struct FModMapJsonInfo* OutInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "MountPakAndLoadLevelFromJson");

	Params::ModBlueprintLibrary_MountPakAndLoadLevelFromJson Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ModFolderPath = std::move(ModFolderPath);
	Parms.JsonFileName = std::move(JsonFileName);
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);

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

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

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.MountPakFile
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    PakPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UModBlueprintLibrary::MountPakFile(const class FString& PakPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "MountPakFile");

	Params::ModBlueprintLibrary_MountPakFile Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.ReadModJsonFile
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    JsonFilePath                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FModMapJsonInfo*                 OutInfo                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UModBlueprintLibrary::ReadModJsonFile(const class FString& JsonFilePath, struct FModMapJsonInfo* OutInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "ReadModJsonFile");

	Params::ModBlueprintLibrary_ReadModJsonFile Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ModBlueprintLibrary.UnloadModLevelInstance
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ULevelStreamingDynamic*           StreamingLevel                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UModBlueprintLibrary::UnloadModLevelInstance(class ULevelStreamingDynamic* StreamingLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ModBlueprintLibrary", "UnloadModLevelInstance");

	Params::ModBlueprintLibrary_UnloadModLevelInstance Parms{};

	Parms.StreamingLevel = StreamingLevel;

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

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

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.MyGameModeBase.GetSeamlessTravelActorListBPF
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// bool                                    bToTransition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>*                  ActorList                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            TargetActroList                                        (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void AMyGameModeBase::GetSeamlessTravelActorListBPF(bool bToTransition, TArray<class AActor*>* ActorList, const TArray<class AActor*>& TargetActroList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyGameModeBase", "GetSeamlessTravelActorListBPF");

	Params::MyGameModeBase_GetSeamlessTravelActorListBPF Parms{};

	Parms.bToTransition = bToTransition;
	Parms.TargetActroList = std::move(TargetActroList);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function PenguinHotel.OnlineBlueprints.ClientTravelURL
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    URL                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETravelType                             TravelType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PlayerIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOnlineBlueprints::ClientTravelURL(class UObject* WorldContextObject, const class FString& URL, ETravelType TravelType, int32 PlayerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OnlineBlueprints", "ClientTravelURL");

	Params::OnlineBlueprints_ClientTravelURL Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.URL = std::move(URL);
	Parms.TravelType = TravelType;
	Parms.PlayerIndex = PlayerIndex;

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

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

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.OnlineBlueprints.ServerTravel
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    URL                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Absolute                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShoudSkipBameNotify                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOnlineBlueprints::ServerTravel(class UObject* WorldContextObject, const class FString& URL, bool Absolute, bool ShoudSkipBameNotify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("OnlineBlueprints", "ServerTravel");

	Params::OnlineBlueprints_ServerTravel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.URL = std::move(URL);
	Parms.Absolute = Absolute;
	Parms.ShoudSkipBameNotify = ShoudSkipBameNotify;

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

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

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.PenTabletBlueprintLibrary.GetPenTabletPressure
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPenTabletBlueprintLibrary::GetPenTabletPressure()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PenTabletBlueprintLibrary", "GetPenTabletPressure");

	Params::PenTabletBlueprintLibrary_GetPenTabletPressure Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.PenTabletBlueprintLibrary.GetPenTabletState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FPenTabletState                  ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPenTabletState UPenTabletBlueprintLibrary::GetPenTabletState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PenTabletBlueprintLibrary", "GetPenTabletState");

	Params::PenTabletBlueprintLibrary_GetPenTabletState Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.PenTabletBlueprintLibrary.IsPenTabletConnected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPenTabletBlueprintLibrary::IsPenTabletConnected()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PenTabletBlueprintLibrary", "IsPenTabletConnected");

	Params::PenTabletBlueprintLibrary_IsPenTabletConnected Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.ApplyPaintSnapshot
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FRuntimePaintCopySnapshot& Snapshot                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::ApplyPaintSnapshot(const struct FRuntimePaintCopySnapshot& Snapshot, bool bApplyPoseToPoseableMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "ApplyPaintSnapshot");

	Params::RuntimePaintCopyComponent_ApplyPaintSnapshot Parms{};

	Parms.Snapshot = std::move(Snapshot);
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.ApplyPaintSnapshotToMesh
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   TargetMeshComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRuntimePaintCopySnapshot& Snapshot                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::ApplyPaintSnapshotToMesh(class UMeshComponent* TargetMeshComponent, const struct FRuntimePaintCopySnapshot& Snapshot, bool bApplyPoseToPoseableMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "ApplyPaintSnapshotToMesh");

	Params::RuntimePaintCopyComponent_ApplyPaintSnapshotToMesh Parms{};

	Parms.TargetMeshComponent = TargetMeshComponent;
	Parms.Snapshot = std::move(Snapshot);
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.BeginSharedMaterialCopy
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   TargetMeshComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MaterialSlot                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInterface*               SharedMaterial                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::BeginSharedMaterialCopy(class UMeshComponent* TargetMeshComponent, int32 MaterialSlot, class UMaterialInterface* SharedMaterial)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "BeginSharedMaterialCopy");

	Params::RuntimePaintCopyComponent_BeginSharedMaterialCopy Parms{};

	Parms.TargetMeshComponent = TargetMeshComponent;
	Parms.MaterialSlot = MaterialSlot;
	Parms.SharedMaterial = SharedMaterial;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.CapturePaintSnapshotFromSource
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class URuntimePaintableComponent*       SourcePaintComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMeshComponent*                   SourceMeshComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRuntimePaintCopySnapshot*       OutSnapshot                                            (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    bIncludePose                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::CapturePaintSnapshotFromSource(class URuntimePaintableComponent* SourcePaintComponent, class UMeshComponent* SourceMeshComponent, struct FRuntimePaintCopySnapshot* OutSnapshot, bool bIncludePose)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "CapturePaintSnapshotFromSource");

	Params::RuntimePaintCopyComponent_CapturePaintSnapshotFromSource Parms{};

	Parms.SourcePaintComponent = SourcePaintComponent;
	Parms.SourceMeshComponent = SourceMeshComponent;
	Parms.bIncludePose = bIncludePose;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.CopyFromPaintComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class URuntimePaintableComponent*       SourcePaintComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMeshComponent*                   SourceMeshComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMeshComponent*                   TargetMeshComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludePose                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::CopyFromPaintComponent(class URuntimePaintableComponent* SourcePaintComponent, class UMeshComponent* SourceMeshComponent, class UMeshComponent* TargetMeshComponent, bool bIncludePose, bool bApplyPoseToPoseableMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "CopyFromPaintComponent");

	Params::RuntimePaintCopyComponent_CopyFromPaintComponent Parms{};

	Parms.SourcePaintComponent = SourcePaintComponent;
	Parms.SourceMeshComponent = SourceMeshComponent;
	Parms.TargetMeshComponent = TargetMeshComponent;
	Parms.bIncludePose = bIncludePose;
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.OnRep_DeferredCopySetup
// (Final, Native, Private)

void URuntimePaintCopyComponent::OnRep_DeferredCopySetup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "OnRep_DeferredCopySetup");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintCopyComponent.CapturePoseSnapshot
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMeshComponent*                   SourceMeshComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRuntimePaintCopyPoseSnapshot*   OutPoseSnapshot                                        (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::CapturePoseSnapshot(class UMeshComponent* SourceMeshComponent, struct FRuntimePaintCopyPoseSnapshot* OutPoseSnapshot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "CapturePoseSnapshot");

	Params::RuntimePaintCopyComponent_CapturePoseSnapshot Parms{};

	Parms.SourceMeshComponent = SourceMeshComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.GetSourcePaintComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class URuntimePaintableComponent*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class URuntimePaintableComponent* URuntimePaintCopyComponent::GetSourcePaintComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "GetSourcePaintComponent");

	Params::RuntimePaintCopyComponent_GetSourcePaintComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.GetSourceParentActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* URuntimePaintCopyComponent::GetSourceParentActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "GetSourceParentActor");

	Params::RuntimePaintCopyComponent_GetSourceParentActor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.IsCopyFinalized
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::IsCopyFinalized() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "IsCopyFinalized");

	Params::RuntimePaintCopyComponent_IsCopyFinalized Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.IsSharingSourceMaterial
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::IsSharingSourceMaterial() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "IsSharingSourceMaterial");

	Params::RuntimePaintCopyComponent_IsSharingSourceMaterial Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintCopyComponent.RestoreCopiedPoseToPoseableMesh
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPoseableMeshComponent*           PoseableMeshComponent                                  (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintCopyComponent::RestoreCopiedPoseToPoseableMesh(class UPoseableMeshComponent* PoseableMeshComponent) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintCopyComponent", "RestoreCopiedPoseToPoseableMesh");

	Params::RuntimePaintCopyComponent_RestoreCopiedPoseToPoseableMesh Parms{};

	Parms.PoseableMeshComponent = PoseableMeshComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintRelayComponent.RelayPaintToServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintStroke&              Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::RelayPaintToServer(class URuntimePaintableComponent* PaintComponent, const struct FPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "RelayPaintToServer");

	Params::RuntimePaintRelayComponent_RelayPaintToServer Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.Stroke = std::move(Stroke);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.RelaySpawnDecoyCopyToServer
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     CopyId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AActor>               DecoyActorClass                                        (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                SpawnTransform                                         (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             DecoyMeshTag                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludePose                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRuntimeDecoyCopyPoseSnapshot&SourcePoseSnapshot                                     (Parm, NativeAccessSpecifierPublic)
// int64                                   RequiredAppliedPaintSequence                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::RelaySpawnDecoyCopyToServer(class URuntimePaintableComponent* PaintComponent, const struct FGuid& CopyId, TSubclassOf<class AActor> DecoyActorClass, const struct FTransform& SpawnTransform, class FName DecoyMeshTag, bool bIncludePose, bool bApplyPoseToPoseableMesh, const struct FRuntimeDecoyCopyPoseSnapshot& SourcePoseSnapshot, int64 RequiredAppliedPaintSequence)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "RelaySpawnDecoyCopyToServer");

	Params::RuntimePaintRelayComponent_RelaySpawnDecoyCopyToServer Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.CopyId = std::move(CopyId);
	Parms.DecoyActorClass = DecoyActorClass;
	Parms.SpawnTransform = std::move(SpawnTransform);
	Parms.DecoyMeshTag = DecoyMeshTag;
	Parms.bIncludePose = bIncludePose;
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;
	Parms.SourcePoseSnapshot = std::move(SourcePoseSnapshot);
	Parms.RequiredAppliedPaintSequence = RequiredAppliedPaintSequence;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.RelayStrokeBatchToServer
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintStrokeBatch&         Batch                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::RelayStrokeBatchToServer(class URuntimePaintableComponent* PaintComponent, const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "RelayStrokeBatchToServer");

	Params::RuntimePaintRelayComponent_RelayStrokeBatchToServer Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.Batch = std::move(Batch);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.RelayTextureSyncToServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::RelayTextureSyncToServer(class URuntimePaintableComponent* PaintComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "RelayTextureSyncToServer");

	Params::RuntimePaintRelayComponent_RelayTextureSyncToServer Parms{};

	Parms.PaintComponent = PaintComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.ServerRelayCompactPaint
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCompactPaintStroke&       Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::ServerRelayCompactPaint(class URuntimePaintableComponent* PaintComponent, const struct FCompactPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "ServerRelayCompactPaint");

	Params::RuntimePaintRelayComponent_ServerRelayCompactPaint Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.Stroke = std::move(Stroke);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.ServerRelayCompactStrokeBatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCompactPaintStrokeBatch&  Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::ServerRelayCompactStrokeBatch(class URuntimePaintableComponent* PaintComponent, const struct FCompactPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "ServerRelayCompactStrokeBatch");

	Params::RuntimePaintRelayComponent_ServerRelayCompactStrokeBatch Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.Batch = std::move(Batch);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.ServerRelayPackedStrokeBatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    PackedData                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   StrokeCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::ServerRelayPackedStrokeBatch(class URuntimePaintableComponent* PaintComponent, const TArray<uint8>& PackedData, int32 StrokeCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "ServerRelayPackedStrokeBatch");

	Params::RuntimePaintRelayComponent_ServerRelayPackedStrokeBatch Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.PackedData = std::move(PackedData);
	Parms.StrokeCount = StrokeCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.ServerRelayPaint
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintStroke&              Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::ServerRelayPaint(class URuntimePaintableComponent* PaintComponent, const struct FPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "ServerRelayPaint");

	Params::RuntimePaintRelayComponent_ServerRelayPaint Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.Stroke = std::move(Stroke);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.ServerRelaySpawnDecoyCopy
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     CopyId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AActor>               DecoyActorClass                                        (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                SpawnTransform                                         (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             DecoyMeshTag                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludePose                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRuntimeDecoyCopyPoseSnapshot&SourcePoseSnapshot                                     (Parm, NativeAccessSpecifierPublic)
// int64                                   RequiredAppliedPaintSequence                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::ServerRelaySpawnDecoyCopy(class URuntimePaintableComponent* PaintComponent, const struct FGuid& CopyId, TSubclassOf<class AActor> DecoyActorClass, const struct FTransform& SpawnTransform, class FName DecoyMeshTag, bool bIncludePose, bool bApplyPoseToPoseableMesh, const struct FRuntimeDecoyCopyPoseSnapshot& SourcePoseSnapshot, int64 RequiredAppliedPaintSequence)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "ServerRelaySpawnDecoyCopy");

	Params::RuntimePaintRelayComponent_ServerRelaySpawnDecoyCopy Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.CopyId = std::move(CopyId);
	Parms.DecoyActorClass = DecoyActorClass;
	Parms.SpawnTransform = std::move(SpawnTransform);
	Parms.DecoyMeshTag = DecoyMeshTag;
	Parms.bIncludePose = bIncludePose;
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;
	Parms.SourcePoseSnapshot = std::move(SourcePoseSnapshot);
	Parms.RequiredAppliedPaintSequence = RequiredAppliedPaintSequence;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.ServerRelayStrokeBatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintStrokeBatch&         Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::ServerRelayStrokeBatch(class URuntimePaintableComponent* PaintComponent, const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "ServerRelayStrokeBatch");

	Params::RuntimePaintRelayComponent_ServerRelayStrokeBatch Parms{};

	Parms.PaintComponent = PaintComponent;
	Parms.Batch = std::move(Batch);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintRelayComponent.ServerRelayTextureSync
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintRelayComponent::ServerRelayTextureSync(class URuntimePaintableComponent* PaintComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintRelayComponent", "ServerRelayTextureSync");

	Params::RuntimePaintRelayComponent_ServerRelayTextureSync Parms{};

	Parms.PaintComponent = PaintComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintReplicationManager.GetQueuedStrokeCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URuntimePaintReplicationManager::GetQueuedStrokeCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintReplicationManager", "GetQueuedStrokeCount");

	Params::RuntimePaintReplicationManager_GetQueuedStrokeCount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintReplicationManager.GetQueuedStrokeCountForComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class URuntimePaintableComponent*       PaintComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URuntimePaintReplicationManager::GetQueuedStrokeCountForComponent(class URuntimePaintableComponent* PaintComponent) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintReplicationManager", "GetQueuedStrokeCountForComponent");

	Params::RuntimePaintReplicationManager_GetQueuedStrokeCountForComponent Parms{};

	Parms.PaintComponent = PaintComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintReplicationManager.GetReplicationPressure
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRuntimePaintReplicationPressure ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FRuntimePaintReplicationPressure URuntimePaintReplicationManager::GetReplicationPressure() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintReplicationManager", "GetReplicationPressure");

	Params::RuntimePaintReplicationManager_GetReplicationPressure Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.AddIgnoreActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::AddIgnoreActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "AddIgnoreActor");

	Params::ScreenSpaceBrushQuery_AddIgnoreActor Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.AddNoCollisionMeshTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::AddNoCollisionMeshTarget(class UMeshComponent* MeshComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "AddNoCollisionMeshTarget");

	Params::ScreenSpaceBrushQuery_AddNoCollisionMeshTarget Parms{};

	Parms.MeshComponent = MeshComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.AddStencilValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   StencilValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::AddStencilValue(int32 StencilValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "AddStencilValue");

	Params::ScreenSpaceBrushQuery_AddStencilValue Parms{};

	Parms.StencilValue = StencilValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.AddTargetActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::AddTargetActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "AddTargetActor");

	Params::ScreenSpaceBrushQuery_AddTargetActor Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.AddTargetComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::AddTargetComponent(class UPrimitiveComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "AddTargetComponent");

	Params::ScreenSpaceBrushQuery_AddTargetComponent Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.ClearIgnoreActors
// (Final, Native, Public, BlueprintCallable)

void UScreenSpaceBrushQuery::ClearIgnoreActors()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "ClearIgnoreActors");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.ClearNoCollisionMeshTargets
// (Final, Native, Public, BlueprintCallable)

void UScreenSpaceBrushQuery::ClearNoCollisionMeshTargets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "ClearNoCollisionMeshTargets");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.ClearTargetActors
// (Final, Native, Public, BlueprintCallable)

void UScreenSpaceBrushQuery::ClearTargetActors()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "ClearTargetActors");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.ClearTargetComponents
// (Final, Native, Public, BlueprintCallable)

void UScreenSpaceBrushQuery::ClearTargetComponents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "ClearTargetComponents");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.DisableStencilFilter
// (Final, Native, Public, BlueprintCallable)

void UScreenSpaceBrushQuery::DisableStencilFilter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "DisableStencilFilter");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.EnableStencilFilter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   StencilValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::EnableStencilFilter(int32 StencilValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "EnableStencilFilter");

	Params::ScreenSpaceBrushQuery_EnableStencilFilter Parms{};

	Parms.StencilValue = StencilValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAllAtScreenPosition
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 ScreenPosition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FBrushQueryResult>*       OutResults                                             (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UScreenSpaceBrushQuery::QueryAllAtScreenPosition(const struct FVector2D& ScreenPosition, class APlayerController* PlayerController, TArray<struct FBrushQueryResult>* OutResults)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAllAtScreenPosition");

	Params::ScreenSpaceBrushQuery_QueryAllAtScreenPosition Parms{};

	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAllAtScreenPositionWithFilter
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 ScreenPosition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBrushQueryFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<struct FBrushQueryResult>*       OutResults                                             (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UScreenSpaceBrushQuery::QueryAllAtScreenPositionWithFilter(const struct FVector2D& ScreenPosition, class APlayerController* PlayerController, const struct FBrushQueryFilter& Filter, TArray<struct FBrushQueryResult>* OutResults)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAllAtScreenPositionWithFilter");

	Params::ScreenSpaceBrushQuery_QueryAllAtScreenPositionWithFilter Parms{};

	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.PlayerController = PlayerController;
	Parms.Filter = std::move(Filter);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAllFromWorldRay
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   RayOrigin                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayDirection                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FBrushQueryResult>*       OutResults                                             (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UScreenSpaceBrushQuery::QueryAllFromWorldRay(const struct FVector& RayOrigin, const struct FVector& RayDirection, TArray<struct FBrushQueryResult>* OutResults)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAllFromWorldRay");

	Params::ScreenSpaceBrushQuery_QueryAllFromWorldRay Parms{};

	Parms.RayOrigin = std::move(RayOrigin);
	Parms.RayDirection = std::move(RayDirection);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAllFromWorldRayWithFilter
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   RayOrigin                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayDirection                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBrushQueryFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<struct FBrushQueryResult>*       OutResults                                             (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UScreenSpaceBrushQuery::QueryAllFromWorldRayWithFilter(const struct FVector& RayOrigin, const struct FVector& RayDirection, const struct FBrushQueryFilter& Filter, TArray<struct FBrushQueryResult>* OutResults)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAllFromWorldRayWithFilter");

	Params::ScreenSpaceBrushQuery_QueryAllFromWorldRayWithFilter Parms{};

	Parms.RayOrigin = std::move(RayOrigin);
	Parms.RayDirection = std::move(RayDirection);
	Parms.Filter = std::move(Filter);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAtMousePosition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryAtMousePosition(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAtMousePosition");

	Params::ScreenSpaceBrushQuery_QueryAtMousePosition Parms{};

	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAtMousePositionWithFilter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBrushQueryFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryAtMousePositionWithFilter(class APlayerController* PlayerController, const struct FBrushQueryFilter& Filter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAtMousePositionWithFilter");

	Params::ScreenSpaceBrushQuery_QueryAtMousePositionWithFilter Parms{};

	Parms.PlayerController = PlayerController;
	Parms.Filter = std::move(Filter);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAtScreenPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 ScreenPosition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryAtScreenPosition(const struct FVector2D& ScreenPosition, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAtScreenPosition");

	Params::ScreenSpaceBrushQuery_QueryAtScreenPosition Parms{};

	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAtScreenPositionWithFilter
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 ScreenPosition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBrushQueryFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryAtScreenPositionWithFilter(const struct FVector2D& ScreenPosition, class APlayerController* PlayerController, const struct FBrushQueryFilter& Filter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAtScreenPositionWithFilter");

	Params::ScreenSpaceBrushQuery_QueryAtScreenPositionWithFilter Parms{};

	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.PlayerController = PlayerController;
	Parms.Filter = std::move(Filter);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAtViewportCenter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryAtViewportCenter(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAtViewportCenter");

	Params::ScreenSpaceBrushQuery_QueryAtViewportCenter Parms{};

	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryAtViewportCenterWithFilter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBrushQueryFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryAtViewportCenterWithFilter(class APlayerController* PlayerController, const struct FBrushQueryFilter& Filter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryAtViewportCenterWithFilter");

	Params::ScreenSpaceBrushQuery_QueryAtViewportCenterWithFilter Parms{};

	Parms.PlayerController = PlayerController;
	Parms.Filter = std::move(Filter);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryDepthAtMousePosition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDepthQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FDepthQueryResult UScreenSpaceBrushQuery::QueryDepthAtMousePosition(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryDepthAtMousePosition");

	Params::ScreenSpaceBrushQuery_QueryDepthAtMousePosition Parms{};

	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryDepthAtScreenPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 ScreenPosition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDepthQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FDepthQueryResult UScreenSpaceBrushQuery::QueryDepthAtScreenPosition(const struct FVector2D& ScreenPosition, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryDepthAtScreenPosition");

	Params::ScreenSpaceBrushQuery_QueryDepthAtScreenPosition Parms{};

	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryDepthAtViewportCenter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDepthQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FDepthQueryResult UScreenSpaceBrushQuery::QueryDepthAtViewportCenter(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryDepthAtViewportCenter");

	Params::ScreenSpaceBrushQuery_QueryDepthAtViewportCenter Parms{};

	Parms.PlayerController = PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryFromWorldRay
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   RayOrigin                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayDirection                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryFromWorldRay(const struct FVector& RayOrigin, const struct FVector& RayDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryFromWorldRay");

	Params::ScreenSpaceBrushQuery_QueryFromWorldRay Parms{};

	Parms.RayOrigin = std::move(RayOrigin);
	Parms.RayDirection = std::move(RayDirection);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.QueryFromWorldRayWithFilter
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   RayOrigin                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayDirection                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBrushQueryFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::QueryFromWorldRayWithFilter(const struct FVector& RayOrigin, const struct FVector& RayDirection, const struct FBrushQueryFilter& Filter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "QueryFromWorldRayWithFilter");

	Params::ScreenSpaceBrushQuery_QueryFromWorldRayWithFilter Parms{};

	Parms.RayOrigin = std::move(RayOrigin);
	Parms.RayDirection = std::move(RayDirection);
	Parms.Filter = std::move(Filter);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.RemoveIgnoreActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::RemoveIgnoreActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "RemoveIgnoreActor");

	Params::ScreenSpaceBrushQuery_RemoveIgnoreActor Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.RemoveNoCollisionMeshTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::RemoveNoCollisionMeshTarget(class UMeshComponent* MeshComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "RemoveNoCollisionMeshTarget");

	Params::ScreenSpaceBrushQuery_RemoveNoCollisionMeshTarget Parms{};

	Parms.MeshComponent = MeshComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.RemoveStencilValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   StencilValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::RemoveStencilValue(int32 StencilValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "RemoveStencilValue");

	Params::ScreenSpaceBrushQuery_RemoveStencilValue Parms{};

	Parms.StencilValue = StencilValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.RemoveTargetActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::RemoveTargetActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "RemoveTargetActor");

	Params::ScreenSpaceBrushQuery_RemoveTargetActor Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.RemoveTargetComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::RemoveTargetComponent(class UPrimitiveComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "RemoveTargetComponent");

	Params::ScreenSpaceBrushQuery_RemoveTargetComponent Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.ResetFilter
// (Final, Native, Public, BlueprintCallable)

void UScreenSpaceBrushQuery::ResetFilter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "ResetFilter");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.SetAllowNoCollisionMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bAllow                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::SetAllowNoCollisionMesh(bool bAllow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "SetAllowNoCollisionMesh");

	Params::ScreenSpaceBrushQuery_SetAllowNoCollisionMesh Parms{};

	Parms.bAllow = bAllow;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.SetDefaultFilter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FBrushQueryFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::SetDefaultFilter(const struct FBrushQueryFilter& Filter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "SetDefaultFilter");

	Params::ScreenSpaceBrushQuery_SetDefaultFilter Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.SetMaxTraceDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::SetMaxTraceDistance(float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "SetMaxTraceDistance");

	Params::ScreenSpaceBrushQuery_SetMaxTraceDistance Parms{};

	Parms.Distance = Distance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.SetTraceChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECollisionChannel                       Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::SetTraceChannel(ECollisionChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "SetTraceChannel");

	Params::ScreenSpaceBrushQuery_SetTraceChannel Parms{};

	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.SetTraceComplex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bComplex                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::SetTraceComplex(bool bComplex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "SetTraceComplex");

	Params::ScreenSpaceBrushQuery_SetTraceComplex Parms{};

	Parms.bComplex = bComplex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.SetUVChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScreenSpaceBrushQuery::SetUVChannel(int32 Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "SetUVChannel");

	Params::ScreenSpaceBrushQuery_SetUVChannel Parms{};

	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.GetDefaultFilter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FBrushQueryFilter                ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryFilter UScreenSpaceBrushQuery::GetDefaultFilter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "GetDefaultFilter");

	Params::ScreenSpaceBrushQuery_GetDefaultFilter Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.GetLastDepthQueryResult
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FDepthQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FDepthQueryResult UScreenSpaceBrushQuery::GetLastDepthQueryResult() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "GetLastDepthQueryResult");

	Params::ScreenSpaceBrushQuery_GetLastDepthQueryResult Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.GetLastQueryResult
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FBrushQueryResult                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FBrushQueryResult UScreenSpaceBrushQuery::GetLastQueryResult() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "GetLastQueryResult");

	Params::ScreenSpaceBrushQuery_GetLastQueryResult Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.ScreenSpaceBrushQuery.WasLastQuerySuccessful
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UScreenSpaceBrushQuery::WasLastQuerySuccessful() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScreenSpaceBrushQuery", "WasLastQuerySuccessful");

	Params::ScreenSpaceBrushQuery_WasLastQuerySuccessful Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.ClearDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)

void USimpleDynamicCapsuleHeightComponent::ClearDesiredCapsuleHalfHeight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "ClearDesiredCapsuleHalfHeight");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.MulticastSetDesiredCapsuleHalfHeight
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// float                                   NewHalfHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USimpleDynamicCapsuleHeightComponent::MulticastSetDesiredCapsuleHalfHeight(float NewHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "MulticastSetDesiredCapsuleHalfHeight");

	Params::SimpleDynamicCapsuleHeightComponent_MulticastSetDesiredCapsuleHalfHeight Parms{};

	Parms.NewHalfHeight = NewHalfHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.OnMoverPostSimulationTick
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void USimpleDynamicCapsuleHeightComponent::OnMoverPostSimulationTick(const struct FMoverTimeStep& TimeStep)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "OnMoverPostSimulationTick");

	Params::SimpleDynamicCapsuleHeightComponent_OnMoverPostSimulationTick Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.OnRep_DesiredCapsuleHalfHeight
// (Final, Native, Protected)

void USimpleDynamicCapsuleHeightComponent::OnRep_DesiredCapsuleHalfHeight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "OnRep_DesiredCapsuleHalfHeight");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.ServerSetDesiredCapsuleHalfHeight
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// float                                   NewHalfHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USimpleDynamicCapsuleHeightComponent::ServerSetDesiredCapsuleHalfHeight(float NewHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "ServerSetDesiredCapsuleHalfHeight");

	Params::SimpleDynamicCapsuleHeightComponent_ServerSetDesiredCapsuleHalfHeight Parms{};

	Parms.NewHalfHeight = NewHalfHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.SetDesiredCapsuleHalfHeight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewHalfHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USimpleDynamicCapsuleHeightComponent::SetDesiredCapsuleHalfHeight(float NewHalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "SetDesiredCapsuleHalfHeight");

	Params::SimpleDynamicCapsuleHeightComponent_SetDesiredCapsuleHalfHeight Parms{};

	Parms.NewHalfHeight = NewHalfHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


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

float USimpleDynamicCapsuleHeightComponent::GetCurrentCapsuleHalfHeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "GetCurrentCapsuleHalfHeight");

	Params::SimpleDynamicCapsuleHeightComponent_GetCurrentCapsuleHalfHeight Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

float USimpleDynamicCapsuleHeightComponent::GetDesiredCapsuleHalfHeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "GetDesiredCapsuleHalfHeight");

	Params::SimpleDynamicCapsuleHeightComponent_GetDesiredCapsuleHalfHeight Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.GetMoverComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMoverComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMoverComponent* USimpleDynamicCapsuleHeightComponent::GetMoverComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "GetMoverComponent");

	Params::SimpleDynamicCapsuleHeightComponent_GetMoverComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.SimpleDynamicCapsuleHeightComponent.WriteDesiredCapsuleHalfHeightInput
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FMoverInputCmdContext&           InputCmd                                               (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USimpleDynamicCapsuleHeightComponent::WriteDesiredCapsuleHalfHeightInput(struct FMoverInputCmdContext& InputCmd) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SimpleDynamicCapsuleHeightComponent", "WriteDesiredCapsuleHalfHeightInput");

	Params::SimpleDynamicCapsuleHeightComponent_WriteDesiredCapsuleHalfHeightInput Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	InputCmd = std::move(Parms.InputCmd);
}


// Function PenguinHotel.TextureUtils.BytesToTexture
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<uint8>&                    ByteArray                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   Width                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Height                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UTextureUtils::BytesToTexture(const TArray<uint8>& ByteArray, int32 Width, int32 Height)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TextureUtils", "BytesToTexture");

	Params::TextureUtils_BytesToTexture Parms{};

	Parms.ByteArray = std::move(ByteArray);
	Parms.Width = Width;
	Parms.Height = Height;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.TextureUtils.TextureToBytes
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UTexture2D*                       Texture                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<uint8>                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<uint8> UTextureUtils::TextureToBytes(class UTexture2D* Texture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TextureUtils", "TextureToBytes");

	Params::TextureUtils_TextureToBytes Parms{};

	Parms.Texture = Texture;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.TextureUtilsLibrary.ConvertRenderTargetToTexture2D
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UTextureRenderTarget2D*           RenderTarget                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UTextureUtilsLibrary::ConvertRenderTargetToTexture2D(class UTextureRenderTarget2D* RenderTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TextureUtilsLibrary", "ConvertRenderTargetToTexture2D");

	Params::TextureUtilsLibrary_ConvertRenderTargetToTexture2D Parms{};

	Parms.RenderTarget = RenderTarget;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.TextureUtilsLibrary.ConvertToTexture2D
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UTexture*                         Texture                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UTextureUtilsLibrary::ConvertToTexture2D(class UTexture* Texture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TextureUtilsLibrary", "ConvertToTexture2D");

	Params::TextureUtilsLibrary_ConvertToTexture2D Parms{};

	Parms.Texture = Texture;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.ApplyPerformancePreset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPaintPerformancePreset                 Preset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ApplyPerformancePreset(EPaintPerformancePreset Preset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ApplyPerformancePreset");

	Params::RuntimePaintableComponent_ApplyPerformancePreset Parms{};

	Parms.Preset = Preset;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.BeginStroke
// (Final, Native, Public, BlueprintCallable)

void URuntimePaintableComponent::BeginStroke()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "BeginStroke");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ClearAllChannels
// (Final, Native, Public, BlueprintCallable)

void URuntimePaintableComponent::ClearAllChannels()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ClearAllChannels");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ClearChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ClearChannel(EPaintChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ClearChannel");

	Params::RuntimePaintableComponent_ClearChannel Parms{};

	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ClearRecordedStrokes
// (Final, Native, Public, BlueprintCallable)

void URuntimePaintableComponent::ClearRecordedStrokes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ClearRecordedStrokes");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.EndStroke
// (Final, Native, Public, BlueprintCallable)

void URuntimePaintableComponent::EndStroke()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "EndStroke");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ExportChannelToBytes
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<uint8>*                          OutData                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::ExportChannelToBytes(EPaintChannel Channel, TArray<uint8>* OutData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ExportChannelToBytes");

	Params::RuntimePaintableComponent_ExportChannelToBytes Parms{};

	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.FlushRecordedStrokesToServer
// (Final, Native, Public, BlueprintCallable)

void URuntimePaintableComponent::FlushRecordedStrokesToServer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "FlushRecordedStrokesToServer");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.HitTestAtScreenPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 ScreenPosition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseCachedTriangles                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FScreenSpacePaintResult          ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FScreenSpacePaintResult URuntimePaintableComponent::HitTestAtScreenPosition(class UMeshComponent* MeshComponent, const struct FVector2D& ScreenPosition, class APlayerController* PlayerController, bool bUseCachedTriangles)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "HitTestAtScreenPosition");

	Params::RuntimePaintableComponent_HitTestAtScreenPosition Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.PlayerController = PlayerController;
	Parms.bUseCachedTriangles = bUseCachedTriangles;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.ImportChannelFromBytes
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    Data                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::ImportChannelFromBytes(EPaintChannel Channel, const TArray<uint8>& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ImportChannelFromBytes");

	Params::RuntimePaintableComponent_ImportChannelFromBytes Parms{};

	Parms.Channel = Channel;
	Parms.Data = std::move(Data);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.InitializePaint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::InitializePaint(class UMeshComponent* MeshComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "InitializePaint");

	Params::RuntimePaintableComponent_InitializePaint Parms{};

	Parms.MeshComponent = MeshComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastApplyDecoyCopyFromLocalView
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults)
// Parameters:
// const struct FGuid&                     CopyId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DecoyActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             DecoyMeshTag                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludePose                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRuntimeDecoyCopyPoseSnapshot&SourcePoseSnapshot                                     (Parm, NativeAccessSpecifierPublic)
// int64                                   RequiredAppliedPaintSequence                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastApplyDecoyCopyFromLocalView(const struct FGuid& CopyId, class AActor* DecoyActor, class FName DecoyMeshTag, bool bIncludePose, bool bApplyPoseToPoseableMesh, const struct FRuntimeDecoyCopyPoseSnapshot& SourcePoseSnapshot, int64 RequiredAppliedPaintSequence)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastApplyDecoyCopyFromLocalView");

	Params::RuntimePaintableComponent_MulticastApplyDecoyCopyFromLocalView Parms{};

	Parms.CopyId = std::move(CopyId);
	Parms.DecoyActor = DecoyActor;
	Parms.DecoyMeshTag = DecoyMeshTag;
	Parms.bIncludePose = bIncludePose;
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;
	Parms.SourcePoseSnapshot = std::move(SourcePoseSnapshot);
	Parms.RequiredAppliedPaintSequence = RequiredAppliedPaintSequence;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastCompactPaint
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FCompactPaintStroke&       Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastCompactPaint(const struct FCompactPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastCompactPaint");

	Params::RuntimePaintableComponent_MulticastCompactPaint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastCompactPaintBatch
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FCompactPaintStrokeBatch&  Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastCompactPaintBatch(const struct FCompactPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastCompactPaintBatch");

	Params::RuntimePaintableComponent_MulticastCompactPaintBatch Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastCompactPaintBatchToOthers
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FCompactPaintStrokeBatch&  Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastCompactPaintBatchToOthers(const struct FCompactPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastCompactPaintBatchToOthers");

	Params::RuntimePaintableComponent_MulticastCompactPaintBatchToOthers Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastCompactPaintToOthers
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FCompactPaintStroke&       Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastCompactPaintToOthers(const struct FCompactPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastCompactPaintToOthers");

	Params::RuntimePaintableComponent_MulticastCompactPaintToOthers Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastPackedPaintBatch
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const TArray<uint8>&                    PackedData                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   StrokeCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastPackedPaintBatch(const TArray<uint8>& PackedData, int32 StrokeCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastPackedPaintBatch");

	Params::RuntimePaintableComponent_MulticastPackedPaintBatch Parms{};

	Parms.PackedData = std::move(PackedData);
	Parms.StrokeCount = StrokeCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastPackedPaintBatchToOthers
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const TArray<uint8>&                    PackedData                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   StrokeCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastPackedPaintBatchToOthers(const TArray<uint8>& PackedData, int32 StrokeCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastPackedPaintBatchToOthers");

	Params::RuntimePaintableComponent_MulticastPackedPaintBatchToOthers Parms{};

	Parms.PackedData = std::move(PackedData);
	Parms.StrokeCount = StrokeCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastPaint
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FPaintStroke&              Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastPaint(const struct FPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastPaint");

	Params::RuntimePaintableComponent_MulticastPaint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastPaintBatch
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FPaintStrokeBatch&         Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastPaintBatch(const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastPaintBatch");

	Params::RuntimePaintableComponent_MulticastPaintBatch Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastPaintBatchToOthers
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FPaintStrokeBatch&         Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastPaintBatchToOthers(const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastPaintBatchToOthers");

	Params::RuntimePaintableComponent_MulticastPaintBatchToOthers Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastPaintToOthers
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FPaintStroke&              Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastPaintToOthers(const struct FPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastPaintToOthers");

	Params::RuntimePaintableComponent_MulticastPaintToOthers Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastSyncChannelData
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    Data                                                   (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastSyncChannelData(EPaintChannel Channel, const TArray<uint8>& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastSyncChannelData");

	Params::RuntimePaintableComponent_MulticastSyncChannelData Parms{};

	Parms.Channel = Channel;
	Parms.Data = std::move(Data);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.MulticastSyncCompressedChannelData
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    CompressedData                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   UncompressedSize                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::MulticastSyncCompressedChannelData(EPaintChannel Channel, const TArray<uint8>& CompressedData, int32 UncompressedSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "MulticastSyncCompressedChannelData");

	Params::RuntimePaintableComponent_MulticastSyncCompressedChannelData Parms{};

	Parms.Channel = Channel;
	Parms.CompressedData = std::move(CompressedData);
	Parms.UncompressedSize = UncompressedSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.OnMaxDecoySpawnCountChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   OldMaxDecoySpawnCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewMaxDecoySpawnCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::OnMaxDecoySpawnCountChanged(int32 OldMaxDecoySpawnCount, int32 NewMaxDecoySpawnCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "OnMaxDecoySpawnCountChanged");

	Params::RuntimePaintableComponent_OnMaxDecoySpawnCountChanged Parms{};

	Parms.OldMaxDecoySpawnCount = OldMaxDecoySpawnCount;
	Parms.NewMaxDecoySpawnCount = NewMaxDecoySpawnCount;

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


// Function PenguinHotel.RuntimePaintableComponent.OnRep_MaxDecoySpawnCount
// (Final, Native, Protected)
// Parameters:
// int32                                   OldMaxDecoySpawnCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::OnRep_MaxDecoySpawnCount(int32 OldMaxDecoySpawnCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "OnRep_MaxDecoySpawnCount");

	Params::RuntimePaintableComponent_OnRep_MaxDecoySpawnCount Parms{};

	Parms.OldMaxDecoySpawnCount = OldMaxDecoySpawnCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.OnRep_SpawnedDecoyActors
// (Final, Native, Protected)

void URuntimePaintableComponent::OnRep_SpawnedDecoyActors()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "OnRep_SpawnedDecoyActors");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.OnTrackedDecoyDestroyed
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::OnTrackedDecoyDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "OnTrackedDecoyDestroyed");

	Params::RuntimePaintableComponent_OnTrackedDecoyDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.PaintAtScreenPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 ScreenPosition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintChannelData&         ChannelData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseCachedTriangles                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FScreenSpacePaintResult          ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FScreenSpacePaintResult URuntimePaintableComponent::PaintAtScreenPosition(class UMeshComponent* MeshComponent, const struct FVector2D& ScreenPosition, class APlayerController* PlayerController, const struct FPaintChannelData& ChannelData, EPaintChannel Channel, bool bUseCachedTriangles)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "PaintAtScreenPosition");

	Params::RuntimePaintableComponent_PaintAtScreenPosition Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.ScreenPosition = std::move(ScreenPosition);
	Parms.PlayerController = PlayerController;
	Parms.ChannelData = std::move(ChannelData);
	Parms.Channel = Channel;
	Parms.bUseCachedTriangles = bUseCachedTriangles;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.PaintAtUV
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 Uv                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintChannelData&         ChannelData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::PaintAtUV(const struct FVector2D& Uv, const struct FPaintChannelData& ChannelData, EPaintChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "PaintAtUV");

	Params::RuntimePaintableComponent_PaintAtUV Parms{};

	Parms.Uv = std::move(Uv);
	Parms.ChannelData = std::move(ChannelData);
	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.PaintAtUVWithBrush
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 Uv                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintChannelData&         ChannelData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRuntimeBrushSettings&     BrushSettings                                          (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::PaintAtUVWithBrush(const struct FVector2D& Uv, const struct FPaintChannelData& ChannelData, const struct FRuntimeBrushSettings& BrushSettings, EPaintChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "PaintAtUVWithBrush");

	Params::RuntimePaintableComponent_PaintAtUVWithBrush Parms{};

	Parms.Uv = std::move(Uv);
	Parms.ChannelData = std::move(ChannelData);
	Parms.BrushSettings = std::move(BrushSettings);
	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.PaintAtWorldPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintChannelData&         ChannelData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::PaintAtWorldPosition(class UMeshComponent* MeshComponent, const struct FVector& WorldLocation, const struct FPaintChannelData& ChannelData, EPaintChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "PaintAtWorldPosition");

	Params::RuntimePaintableComponent_PaintAtWorldPosition Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.WorldLocation = std::move(WorldLocation);
	Parms.ChannelData = std::move(ChannelData);
	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.PaintStrokeUV
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 UvStart                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 UvEnd                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintChannelData&         ChannelData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::PaintStrokeUV(const struct FVector2D& UvStart, const struct FVector2D& UvEnd, const struct FPaintChannelData& ChannelData, EPaintChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "PaintStrokeUV");

	Params::RuntimePaintableComponent_PaintStrokeUV Parms{};

	Parms.UvStart = std::move(UvStart);
	Parms.UvEnd = std::move(UvEnd);
	Parms.ChannelData = std::move(ChannelData);
	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.RequestFullTextureSync
// (Final, Native, Public, BlueprintCallable)

void URuntimePaintableComponent::RequestFullTextureSync()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "RequestFullTextureSync");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.RequestPaintOnServer
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 Uv                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintChannelData&         ChannelData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::RequestPaintOnServer(const struct FVector2D& Uv, const struct FPaintChannelData& ChannelData, EPaintChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "RequestPaintOnServer");

	Params::RuntimePaintableComponent_RequestPaintOnServer Parms{};

	Parms.Uv = std::move(Uv);
	Parms.ChannelData = std::move(ChannelData);
	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.RequestStrokeBatchOnServer
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPaintStrokeBatch&         Batch                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::RequestStrokeBatchOnServer(const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "RequestStrokeBatchOnServer");

	Params::RuntimePaintableComponent_RequestStrokeBatchOnServer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SendCustomStrokeBatchToServer
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPaintStrokeBatch&         Batch                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SendCustomStrokeBatchToServer(const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SendCustomStrokeBatchToServer");

	Params::RuntimePaintableComponent_SendCustomStrokeBatchToServer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SendPaintToServer
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 Uv                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPaintChannelData&         ChannelData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SendPaintToServer(const struct FVector2D& Uv, const struct FPaintChannelData& ChannelData, EPaintChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SendPaintToServer");

	Params::RuntimePaintableComponent_SendPaintToServer Parms{};

	Parms.Uv = std::move(Uv);
	Parms.ChannelData = std::move(ChannelData);
	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SendStrokeBatchToServer
// (Final, Native, Public, BlueprintCallable)

void URuntimePaintableComponent::SendStrokeBatchToServer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SendStrokeBatchToServer");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerCompactPaint
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FCompactPaintStroke&       Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerCompactPaint(const struct FCompactPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerCompactPaint");

	Params::RuntimePaintableComponent_ServerCompactPaint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerCompactPaintBatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FCompactPaintStrokeBatch&  Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerCompactPaintBatch(const struct FCompactPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerCompactPaintBatch");

	Params::RuntimePaintableComponent_ServerCompactPaintBatch Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerPackedPaintBatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const TArray<uint8>&                    PackedData                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   StrokeCount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerPackedPaintBatch(const TArray<uint8>& PackedData, int32 StrokeCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerPackedPaintBatch");

	Params::RuntimePaintableComponent_ServerPackedPaintBatch Parms{};

	Parms.PackedData = std::move(PackedData);
	Parms.StrokeCount = StrokeCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerPaint
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FPaintStroke&              Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerPaint(const struct FPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerPaint");

	Params::RuntimePaintableComponent_ServerPaint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerPaintBatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FPaintStrokeBatch&         Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerPaintBatch(const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerPaintBatch");

	Params::RuntimePaintableComponent_ServerPaintBatch Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerRequestTextureSync
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void URuntimePaintableComponent::ServerRequestTextureSync()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerRequestTextureSync");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerSendPaint
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FPaintStroke&              Stroke                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerSendPaint(const struct FPaintStroke& Stroke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerSendPaint");

	Params::RuntimePaintableComponent_ServerSendPaint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerSendStrokeBatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FPaintStrokeBatch&         Batch                                                  (Parm, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerSendStrokeBatch(const struct FPaintStrokeBatch& Batch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerSendStrokeBatch");

	Params::RuntimePaintableComponent_ServerSendStrokeBatch Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerSetMaxDecoySpawnCount
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// int32                                   NewMaxDecoySpawnCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerSetMaxDecoySpawnCount(int32 NewMaxDecoySpawnCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerSetMaxDecoySpawnCount");

	Params::RuntimePaintableComponent_ServerSetMaxDecoySpawnCount Parms{};

	Parms.NewMaxDecoySpawnCount = NewMaxDecoySpawnCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.ServerSpawnDecoyCopyFromLocalView
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     CopyId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AActor>               DecoyActorClass                                        (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                SpawnTransform                                         (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             DecoyMeshTag                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludePose                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRuntimeDecoyCopyPoseSnapshot&SourcePoseSnapshot                                     (Parm, NativeAccessSpecifierPublic)
// int64                                   RequiredAppliedPaintSequence                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::ServerSpawnDecoyCopyFromLocalView(const struct FGuid& CopyId, TSubclassOf<class AActor> DecoyActorClass, const struct FTransform& SpawnTransform, class FName DecoyMeshTag, bool bIncludePose, bool bApplyPoseToPoseableMesh, const struct FRuntimeDecoyCopyPoseSnapshot& SourcePoseSnapshot, int64 RequiredAppliedPaintSequence)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "ServerSpawnDecoyCopyFromLocalView");

	Params::RuntimePaintableComponent_ServerSpawnDecoyCopyFromLocalView Parms{};

	Parms.CopyId = std::move(CopyId);
	Parms.DecoyActorClass = DecoyActorClass;
	Parms.SpawnTransform = std::move(SpawnTransform);
	Parms.DecoyMeshTag = DecoyMeshTag;
	Parms.bIncludePose = bIncludePose;
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;
	Parms.SourcePoseSnapshot = std::move(SourcePoseSnapshot);
	Parms.RequiredAppliedPaintSequence = RequiredAppliedPaintSequence;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetBrushBlendMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPaintBlendMode                         BlendMode                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetBrushBlendMode(EPaintBlendMode BlendMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetBrushBlendMode");

	Params::RuntimePaintableComponent_SetBrushBlendMode Parms{};

	Parms.BlendMode = BlendMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetBrushFalloff
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBrushFalloff                           Falloff                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetBrushFalloff(EBrushFalloff Falloff)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetBrushFalloff");

	Params::RuntimePaintableComponent_SetBrushFalloff Parms{};

	Parms.Falloff = Falloff;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetBrushHardness
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Hardness                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetBrushHardness(float Hardness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetBrushHardness");

	Params::RuntimePaintableComponent_SetBrushHardness Parms{};

	Parms.Hardness = Hardness;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetBrushOpacity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Opacity                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetBrushOpacity(float Opacity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetBrushOpacity");

	Params::RuntimePaintableComponent_SetBrushOpacity Parms{};

	Parms.Opacity = Opacity;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetBrushRadius
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetBrushRadius(float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetBrushRadius");

	Params::RuntimePaintableComponent_SetBrushRadius Parms{};

	Parms.Radius = Radius;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetBrushSettings
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FRuntimeBrushSettings&     NewSettings                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetBrushSettings(const struct FRuntimeBrushSettings& NewSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetBrushSettings");

	Params::RuntimePaintableComponent_SetBrushSettings Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetBrushTexture
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UTexture2D*                       Texture                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetBrushTexture(class UTexture2D* Texture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetBrushTexture");

	Params::RuntimePaintableComponent_SetBrushTexture Parms{};

	Parms.Texture = Texture;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SetMaxDecoySpawnCount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   NewMaxDecoySpawnCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::SetMaxDecoySpawnCount(int32 NewMaxDecoySpawnCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SetMaxDecoySpawnCount");

	Params::RuntimePaintableComponent_SetMaxDecoySpawnCount Parms{};

	Parms.NewMaxDecoySpawnCount = NewMaxDecoySpawnCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function PenguinHotel.RuntimePaintableComponent.SpawnDecoyCopyFromLocalView
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// TSubclassOf<class AActor>               DecoyActorClass                                        (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                SpawnTransform                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGuid*                           OutCopyId                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             DecoyMeshTag                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludePose                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyPoseToPoseableMesh                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::SpawnDecoyCopyFromLocalView(TSubclassOf<class AActor> DecoyActorClass, const struct FTransform& SpawnTransform, struct FGuid* OutCopyId, class FName DecoyMeshTag, bool bIncludePose, bool bApplyPoseToPoseableMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "SpawnDecoyCopyFromLocalView");

	Params::RuntimePaintableComponent_SpawnDecoyCopyFromLocalView Parms{};

	Parms.DecoyActorClass = DecoyActorClass;
	Parms.SpawnTransform = std::move(SpawnTransform);
	Parms.DecoyMeshTag = DecoyMeshTag;
	Parms.bIncludePose = bIncludePose;
	Parms.bApplyPoseToPoseableMesh = bApplyPoseToPoseableMesh;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetDominantPaintMaterialPatterns
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FPaintMaterialPattern>*   OutPatterns                                            (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   MaxPatterns                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SampleStep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AlphaThreshold                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::GetDominantPaintMaterialPatterns(TArray<struct FPaintMaterialPattern>* OutPatterns, int32 MaxPatterns, int32 SampleStep, float AlphaThreshold) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetDominantPaintMaterialPatterns");

	Params::RuntimePaintableComponent_GetDominantPaintMaterialPatterns Parms{};

	Parms.MaxPatterns = MaxPatterns;
	Parms.SampleStep = SampleStep;
	Parms.AlphaThreshold = AlphaThreshold;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetInitializedPaintMesh
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMeshComponent*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMeshComponent* URuntimePaintableComponent::GetInitializedPaintMesh() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetInitializedPaintMesh");

	Params::RuntimePaintableComponent_GetInitializedPaintMesh Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetMaxDecoySpawnCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URuntimePaintableComponent::GetMaxDecoySpawnCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetMaxDecoySpawnCount");

	Params::RuntimePaintableComponent_GetMaxDecoySpawnCount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetRecordedStrokeBatch
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FPaintStrokeBatch                ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FPaintStrokeBatch URuntimePaintableComponent::GetRecordedStrokeBatch() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetRecordedStrokeBatch");

	Params::RuntimePaintableComponent_GetRecordedStrokeBatch Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetRecordedStrokeCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URuntimePaintableComponent::GetRecordedStrokeCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetRecordedStrokeCount");

	Params::RuntimePaintableComponent_GetRecordedStrokeCount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetRenderTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPaintChannel                           Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTextureRenderTarget2D*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTextureRenderTarget2D* URuntimePaintableComponent::GetRenderTarget(EPaintChannel Channel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetRenderTarget");

	Params::RuntimePaintableComponent_GetRenderTarget Parms{};

	Parms.Channel = Channel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetSpawnedDecoyActorCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URuntimePaintableComponent::GetSpawnedDecoyActorCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetSpawnedDecoyActorCount");

	Params::RuntimePaintableComponent_GetSpawnedDecoyActorCount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.GetSpawnedDecoyActors
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AActor*>*                  OutDecoyActors                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void URuntimePaintableComponent::GetSpawnedDecoyActors(TArray<class AActor*>* OutDecoyActors) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "GetSpawnedDecoyActors");

	Params::RuntimePaintableComponent_GetSpawnedDecoyActors Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function PenguinHotel.RuntimePaintableComponent.IsInitialized
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::IsInitialized() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "IsInitialized");

	Params::RuntimePaintableComponent_IsInitialized Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.RuntimePaintableComponent.IsStroking
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URuntimePaintableComponent::IsStroking() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RuntimePaintableComponent", "IsStroking");

	Params::RuntimePaintableComponent_IsStroking Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function PenguinHotel.MapSortBlueprintLibrary.SortMapByFloatValue
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TMap<int32, float>&                     TargetMap                                              (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bAscending                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMapSortBlueprintLibrary::SortMapByFloatValue(TMap<int32, float>& TargetMap, bool bAscending)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MapSortBlueprintLibrary", "SortMapByFloatValue");

	Params::MapSortBlueprintLibrary_SortMapByFloatValue Parms{};

	Parms.TargetMap = std::move(TargetMap);
	Parms.bAscending = bAscending;

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

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

	Func->FunctionFlags = Flgs;

	TargetMap = std::move(Parms.TargetMap);
}


// Function PenguinHotel.MapSortBlueprintLibrary.SortMapByIntValue
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TMap<int32, int32>&                     TargetMap                                              (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bAscending                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMapSortBlueprintLibrary::SortMapByIntValue(TMap<int32, int32>& TargetMap, bool bAscending)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MapSortBlueprintLibrary", "SortMapByIntValue");

	Params::MapSortBlueprintLibrary_SortMapByIntValue Parms{};

	Parms.TargetMap = std::move(TargetMap);
	Parms.bAscending = bAscending;

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

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

	Func->FunctionFlags = Flgs;

	TargetMap = std::move(Parms.TargetMap);
}


SDK_NAMESPACE_END
